PairDrop: Local AirDrop Alternative for Any Device

Overview

PairDrop is a brilliant self-hosted web application that brings Apple AirDrop-like functionality to every device on your network, regardless of operating system. Built on WebRTC technology, it enables instant peer-to-peer file transfers between phones, tablets, laptops, and desktops - all through a simple web browser interface.

Imagine this: you’re on your phone and want to send a photo to your laptop. No cables, no cloud uploads, no email attachments, no messaging apps. Just open a webpage on both devices and drag-and-drop. PairDrop makes this magic happen with zero configuration required on the client side.

As the spiritual successor to SnapDrop, PairDrop adds crucial features like room codes for controlled sharing, persistent device names, and improved network discovery. It’s perfect for families, small offices, or anyone who frequently shares files between devices on the same network.

What You’ll Learn:

• Deploy PairDrop in minutes using Docker
• Enable instant file sharing across all your devices
• Configure room codes for private sharing sessions
• Set up persistent device naming
• Implement HTTPS for secure transfers
• Optimize for local network performance
• Troubleshoot common connection issues
• Extend PairDrop with custom domains and branding

Why Choose PairDrop?

Unlike cloud-based file sharing or AirDrop’s ecosystem lock-in, PairDrop works universally. Android, iOS, Windows, macOS, Linux - if it has a modern web browser, it can use PairDrop. Files transfer directly between devices using WebRTC, never touching your server’s storage. It’s private, fast, and incredibly simple.

---

Prerequisites

Before starting, ensure you have:

Required:

• Docker and Docker Compose installed
• Local network with devices able to communicate
• Network port 3000 available (or your chosen port)
• Modern web browser on client devices (Chrome, Firefox, Safari, Edge)

Optional but Recommended:

• Reverse proxy for HTTPS (Traefik, Nginx Proxy Manager, Caddy)
• Local DNS or hosts file entries for easy access
• Basic understanding of WebRTC and P2P networking

Hardware Requirements:

• Minimal: 50 MB RAM, any CPU
• PairDrop is extremely lightweight - perfect for Raspberry Pi

Pre-Deployment Checklist:

• Docker environment functional
• Port 3000 available (or alternative chosen)
• Devices on same network/subnet
• Browser support verified on client devices
• Domain name prepared (if using HTTPS)

---

Understanding PairDrop

What is PairDrop?

PairDrop is a fork of SnapDrop that adds essential features while maintaining the same simplicity. It’s a web-based file sharing application that:

1. Discovers devices on your local network automatically
2. Establishes direct connections between devices using WebRTC
3. Transfers files peer-to-peer without storing them on the server
4. Works instantly - no apps to install, no accounts to create

How PairDrop Works

Device A (Browser)                    Device B (Browser)
       ↓                                     ↓
   WebSocket                             WebSocket
       ↓                                     ↓
       └─────→ PairDrop Server ←────────────┘
              (Signaling only)
                     ↓
              WebRTC Connection
              Established
                     ↓
Device A ←──────────────────────────────→ Device B
          (Direct P2P File Transfer)

The process:

1. Discovery: Devices connect to PairDrop server via WebSocket
2. Signaling: Server helps devices discover each other
3. WebRTC: Devices establish direct peer-to-peer connection
4. Transfer: Files flow directly between devices (not through server)
5. Completion: Connection closes after transfer

Key point: The server only facilitates discovery and signaling. Files never pass through the server, ensuring privacy and speed.

Core Features

Instant Discovery:

• Devices appear automatically when they open PairDrop
• Real-time updates as devices join/leave
• Visual device identification with icons and names

Universal Compatibility:

• Works on any device with a modern browser
• iOS, Android, Windows, macOS, Linux
• No apps or extensions required

Room Codes:

• Create private sharing rooms with custom codes
• Only devices in the same room can see each other
• Perfect for public networks or controlled sharing

Persistent Device Names:

• Set a custom name that persists across sessions
• Easy identification of your devices
• Stored in browser local storage

File Type Support:

• Any file type, any size (limited by browser memory)
• Multiple file selection
• Folder sharing (as zip archives)
• Text snippets and clipboard sharing

Privacy Focused:

• End-to-end encrypted transfers via WebRTC
• No file storage on server
• No logging of file contents
• Open source for transparency

PairDrop vs. Alternatives

---

Installation and Deployment

Method 1: Docker Compose (Recommended)

The simplest deployment method for most homelabs.

Create directory structure:

# Create PairDrop directory
mkdir -p /opt/pairdrop
cd /opt/pairdrop

Create docker-compose.yml:

version: '3.8'

services:
  pairdrop:
    image: lscr.io/linuxserver/pairdrop:latest
    container_name: pairdrop
    restart: unless-stopped

    # Environment variables
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      # Optional: Set rate limiting
      - RATE_LIMIT=false
      # Optional: Enable WebRTC debugging
      - DEBUG_MODE=false

    # Port mapping
    ports:
      - "3000:3000"

    # Optional: Mount config for persistence
    volumes:
      - ./config:/config

    # Security options
    security_opt:
      - no-new-privileges:true

    # Resource limits (optional)
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 256M
        reservations:
          cpus: '0.1'
          memory: 64M

    # Network
    networks:
      - pairdrop-net

networks:
  pairdrop-net:
    driver: bridge

Deploy PairDrop:

# Start the container
docker-compose up -d

# View logs
docker-compose logs -f pairdrop

# Check status
docker-compose ps

Access PairDrop:

Open your browser to http://YOUR-SERVER-IP:3000

That’s it! PairDrop is ready to use.

Method 2: Standard Docker Run

For quick testing or simple setups:

docker run -d   --name=pairdrop   --restart=unless-stopped   -e PUID=1000   -e PGID=1000   -e TZ=America/New_York   -p 3000:3000   lscr.io/linuxserver/pairdrop:latest

Method 3: Official PairDrop Image

Using the official upstream image:

docker run -d   --name=pairdrop   --restart=unless-stopped   -p 3000:3000   ghcr.io/schlagmichdoch/pairdrop:latest

Verify Installation

Check container is running:

docker ps | grep pairdrop

Test accessibility:

curl http://localhost:3000
# Should return HTML content

Check logs for errors:

docker logs pairdrop

---

Using PairDrop

Basic File Sharing

Step 1: Open PairDrop on both devices

• Device A: Open http://YOUR-SERVER-IP:3000
• Device B: Open http://YOUR-SERVER-IP:3000

Both devices should appear on each screen automatically.

Step 2: Send a file

On the sending device:

1. Click on the receiving device’s icon
2. Select file(s) to send
3. Files transfer instantly

On the receiving device:

1. Accept the incoming transfer
2. File downloads automatically

That’s it! No configuration required.

Setting Device Names

Persistent device identification:

1. Open PairDrop
2. Click on your device name (default is auto-generated)
3. Enter your custom name (e.g., “John’s iPhone”)
4. Click Save

Your custom name persists across sessions (stored in browser local storage).

Using Room Codes

Create a private sharing room:

1. Open PairDrop
2. Click the ”+” icon or “Create Room” button
3. Enter a room code (e.g., “family2025”)
4. Click Join

Join an existing room:

1. Open PairDrop
2. Click “Join Room”
3. Enter the same room code
4. Click Join

Benefits:

• Only devices with the room code can see each other
• Perfect for public networks (coffee shops, airports)
• Great for temporary sharing with specific people

Leave a room:

Click “Leave Room” or close the browser tab.

Sending Multiple Files

Select multiple files:

1. Click on recipient device
2. In file picker, select multiple files (Ctrl+Click or Cmd+Click)
3. Send all at once

Folders:

Some browsers support folder selection:

1. Right-click on recipient device
2. Choose “Send Folder” (if available)
3. Files are compressed and sent as ZIP

Text Snippets

Send clipboard text:

1. Click on recipient device
2. Choose “Send Message” or type directly
3. Enter or paste text
4. Send

Perfect for sharing:

• URLs
• Code snippets
• Notes
• Clipboard contents

---

Network Configuration

Local Network Access

Finding your server IP:

# Linux/macOS
hostname -I

# Or
ip addr show

# Windows
ipconfig

Accessing from devices:

All devices must be on the same network:

• Phone: http://192.168.1.100:3000
• Laptop: http://192.168.1.100:3000
• Tablet: http://192.168.1.100:3000

DNS Setup for Easy Access

Option 1: Local DNS (recommended)

If you have Pi-hole, AdGuard Home, or router DNS:

Add DNS record:

pairdrop.local → 192.168.1.100

Users access: http://pairdrop.local:3000

Option 2: Hosts file

Edit hosts file on each device:

Linux/macOS: /etc/hosts Windows: C:\Windows\System32\drivers\etc\hosts

Add:

192.168.1.100 pairdrop.local

Firewall Configuration

Allow PairDrop port:

UFW (Ubuntu):

# Allow from local network only
sudo ufw allow from 192.168.1.0/24 to any port 3000 proto tcp

Firewalld (RHEL/CentOS):

sudo firewall-cmd --permanent --add-port=3000/tcp
sudo firewall-cmd --reload

Windows Firewall:

New-NetFirewallRule -DisplayName "PairDrop" -Direction Inbound -LocalPort 3000 -Protocol TCP -Action Allow

---

HTTPS and Reverse Proxy Setup

Why HTTPS Matters for PairDrop

Critical reasons:

1. WebRTC Requirements: Modern browsers require HTTPS for WebRTC on non-localhost
2. Security: Encrypt signaling data
3. Features: Some browser features (clipboard, camera) need HTTPS

Without HTTPS, PairDrop works only on:

• Same device (localhost)
• Local network with HTTP (limited features)

With HTTPS, full functionality everywhere.

Traefik Configuration

Update docker-compose.yml:

version: '3.8'

services:
  pairdrop:
    image: lscr.io/linuxserver/pairdrop:latest
    container_name: pairdrop
    restart: unless-stopped

    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York

    networks:
      - traefik

    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.pairdrop.rule=Host(`drop.yourdomain.com`)"
      - "traefik.http.routers.pairdrop.entrypoints=websecure"
      - "traefik.http.routers.pairdrop.tls.certresolver=letsencrypt"
      - "traefik.http.services.pairdrop.loadbalancer.server.port=3000"

networks:
  traefik:
    external: true

Deploy:

docker-compose up -d

Access at: https://drop.yourdomain.com

Nginx Proxy Manager

1. Log into Nginx Proxy Manager
2. Add Proxy Host:
   • Domain Names: drop.yourdomain.com
   • Scheme: http
   • Forward Hostname/IP: pairdrop (or container IP)
   • Forward Port: 3000
   • Enable Websockets Support (critical!)
3. SSL tab: Request Let’s Encrypt certificate
4. Enable Force SSL

Caddy Configuration

Caddyfile:

drop.yourdomain.com {
    reverse_proxy pairdrop:3000

    # WebSocket support (automatic in Caddy)
    # No additional config needed!
}

Cloudflare Tunnel

config.yml:

tunnel: YOUR-TUNNEL-ID
credentials-file: /root/.cloudflared/YOUR-TUNNEL-ID.json

ingress:
  - hostname: drop.yourdomain.com
    service: http://pairdrop:3000
  - service: http_status:404

Important: Enable WebSocket support in Cloudflare dashboard.

---

Advanced Configuration

Custom Branding

PairDrop supports custom theming and branding.

Environment variables:

environment:
  - PUID=1000
  - PGID=1000
  - TITLE=My Family Drop
  - DESCRIPTION=Private file sharing
  - PRIMARY_COLOR=#3498db

Rate Limiting

Prevent abuse on public-facing deployments:

environment:
  - RATE_LIMIT=true
  - RATE_LIMIT_REQUESTS=100
  - RATE_LIMIT_WINDOW=900000  # 15 minutes in ms

TURN/STUN Server Configuration

For better connectivity across complex networks:

Default: PairDrop uses public STUN servers.

Custom STUN/TURN:

environment:
  - RTC_CONFIG='{"iceServers":[{"urls":"stun:stun.l.google.com:19302"},{"urls":"turn:YOUR-TURN-SERVER:3478","username":"user","credential":"pass"}]}'

Host your own TURN server for maximum privacy:

services:
  coturn:
    image: coturn/coturn:latest
    container_name: coturn
    restart: unless-stopped
    network_mode: host
    volumes:
      - ./coturn/turnserver.conf:/etc/turnserver.conf:ro
    command: ["-c", "/etc/turnserver.conf"]

turnserver.conf:

listening-port=3478
fingerprint
lt-cred-mech
user=username:password
realm=yourdomain.com

WebSocket Persistence

Ensure WebSocket connections survive proxy restarts:

Nginx:

location / {
    proxy_pass http://pairdrop:3000;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header Host $host;
    proxy_read_timeout 86400;
}

---

Mobile Access and PWA

Progressive Web App

PairDrop works as a PWA (Progressive Web App):

iOS (Safari):

1. Open PairDrop
2. Tap Share button
3. “Add to Home Screen”
4. PairDrop now acts like a native app

Android (Chrome):

1. Open PairDrop
2. Tap menu (three dots)
3. “Add to Home screen”
4. PairDrop available in app drawer

Benefits:

• Full-screen experience
• App icon on home screen
• Faster loading (cached)
• Offline UI (online needed for transfers)

iOS Shortcuts Integration

Create Shortcuts for common tasks:

Quick Share Shortcut:

1. Open Shortcuts app
2. Create new shortcut
3. Add “Open URL” action: https://drop.yourdomain.com
4. Add to home screen

QR Code Access

Generate QR codes for easy device onboarding:

# Install qrencode
sudo apt install qrencode

# Generate QR code
qrencode -t ANSIUTF8 "http://192.168.1.100:3000"

# Or save as PNG
qrencode -o pairdrop-qr.png "http://192.168.1.100:3000"

Print and post QR codes around your home/office for quick access.

---

Troubleshooting

Issue 1: Devices Don’t See Each Other

Symptoms:

• Open PairDrop on multiple devices
• Devices don’t appear in the list

Diagnostics:

Check WebSocket connection:

1. Open browser developer tools (F12)
2. Go to Console tab
3. Look for WebSocket connection messages
4. Check Network tab for WS connections

Common causes and fixes:

1. Different networks/subnets:

# Verify devices on same network
# On each device:
# Linux/macOS:
ip route get 8.8.8.8

# Windows:
route print

Devices must be on the same subnet (e.g., 192.168.1.x).

2. WebSocket blocked by firewall:

# Allow WebSocket connections
sudo ufw allow 3000/tcp

3. Reverse proxy not configured for WebSockets:

Ensure your proxy passes WebSocket headers (see HTTPS section).

4. Browser cache issues:

Clear browser cache and reload:

• Chrome: Ctrl+Shift+Delete
• Firefox: Ctrl+Shift+Delete
• Safari: Cmd+Option+E

Issue 2: File Transfer Fails

Symptoms:

• Devices see each other
• Transfer starts but fails or hangs

Diagnostics:

Check browser console for errors:

Look for WebRTC connection errors:

• “ICE connection failed”
• “Connection timeout”
• “Data channel error”

Common fixes:

1. WebRTC blocked by firewall/NAT:

If on complex network, configure TURN server (see Advanced Configuration).

2. File too large for browser memory:

WebRTC transfers are limited by browser RAM. For very large files:

• Use smaller file chunks
• Use alternative method (FileBrowser, Syncthing)

3. Connection interrupted:

Ensure stable network:

# Test connectivity between devices
ping DEVICE-IP

4. Browser not supported:

Update to latest browser version:

• Chrome 90+
• Firefox 88+
• Safari 14+
• Edge 90+

Issue 3: HTTPS Not Working

Symptoms:

• HTTP works, HTTPS doesn’t
• Certificate errors
• WebRTC features disabled

Diagnostics:

# Check certificate
openssl s_client -connect drop.yourdomain.com:443 -servername drop.yourdomain.com

# Check DNS
nslookup drop.yourdomain.com

# Test from server
curl -I https://drop.yourdomain.com

Common fixes:

1. Certificate not trusted:

Ensure Let’s Encrypt certificate is issued and valid.

2. DNS not resolving:

Add DNS A record pointing to your server IP.

3. Cloudflare SSL mode:

Set to “Full” or “Full (strict)”, not “Flexible”.

4. Reverse proxy misconfiguration:

Verify proxy configuration includes WebSocket support.

Issue 4: Room Codes Not Working

Symptoms:

• Create room code
• Other devices can’t join
• Devices in room don’t see each other

Fixes:

1. Case sensitivity:

Room codes are case-sensitive: “Room123” ≠ “room123”

2. Clear browser storage:

// In browser console:
localStorage.clear();
location.reload();

3. Different PairDrop instances:

Ensure all devices connect to the SAME PairDrop server URL.

Issue 5: High Resource Usage

Symptoms:

• Server CPU or RAM usage high
• Transfers slow

Diagnostics:

# Check container resources
docker stats pairdrop

# Check system resources
htop

Fixes:

1. Set resource limits:

deploy:
  resources:
    limits:
      cpus: '0.5'
      memory: 256M

2. Reduce concurrent transfers:

Limit number of simultaneous connections (requires code modification or proxy rate limiting).

3. Check for runaway connections:

# Check open connections
docker exec pairdrop netstat -an | grep ESTABLISHED | wc -l

---

Security Considerations

Network Exposure

Best practices:

1. Local network only (most secure):

# Firewall: Allow only from local subnet
sudo ufw allow from 192.168.1.0/24 to any port 3000

2. VPN access (recommended for remote):

Use Tailscale or WireGuard instead of exposing PairDrop publicly.

3. Public access (requires HTTPS):

If you must expose publicly:

• Always use HTTPS
• Enable rate limiting
• Monitor access logs
• Consider authentication proxy

Authentication

PairDrop has no built-in authentication. For added security:

Option 1: Reverse proxy authentication

Use Authelia, Authentik, or basic auth:

Nginx with basic auth:

location / {
    auth_basic "PairDrop Access";
    auth_basic_user_file /etc/nginx/.htpasswd;

    proxy_pass http://pairdrop:3000;
}

Option 2: VPN requirement

Only allow access via VPN (Tailscale, WireGuard).

Privacy and Data

What PairDrop logs:

• Connected device IPs (for session management)
• WebSocket connections
• Room codes (for routing)

What PairDrop does NOT log:

• File contents
• File names
• File types
• Transfer data

Data flow: Files transfer directly between browsers via WebRTC. Server never sees file data.

---

Performance Optimization

Network Optimization

Use wired connections when possible:

• Server: Ethernet
• Desktop devices: Ethernet
• Mobile: Strong Wi-Fi signal

Optimize Wi-Fi:

# Check Wi-Fi signal strength
iwconfig wlan0 | grep Signal

# Use 5 GHz band for better performance
# Configure in router settings

Browser Optimization

For best performance:

1. Use Chrome or Edge (best WebRTC performance)
2. Close unnecessary tabs
3. Disable browser extensions temporarily
4. Clear cache regularly

Server Optimization

Minimal resources needed:

PairDrop is extremely lightweight. No optimization typically needed.

If hosting many concurrent users:

deploy:
  resources:
    limits:
      cpus: '2'
      memory: 512M

---

Use Cases and Examples

Use Case 1: Family Photo Sharing

Scenario: Share vacation photos from phone to family laptop.

Setup:

1. Deploy PairDrop on home server
2. Create bookmarks on all family devices
3. Optional: Create family room code “family2025”

Usage:

1. Take photos on phone
2. Open PairDrop on phone and laptop
3. Join “family2025” room on both
4. Drag-and-drop photos from phone to laptop
5. Photos transfer instantly without cloud upload

Use Case 2: Work File Exchange

Scenario: Quick file sharing between work computers without email.

Setup:

1. Deploy PairDrop on local work network
2. Set custom device names (e.g., “Marketing Laptop”)
3. Create departmental room codes

Usage:

• Marketing team: Join “marketing” room
• Share presentations, documents, images instantly
• No email size limits
• No waiting for cloud uploads

Use Case 3: IoT and Raspberry Pi

Scenario: Transfer files to/from headless Raspberry Pi.

Setup:

1. Run PairDrop on Pi or separate server
2. Access from any device on network
3. Bookmark for quick access

Usage:

• Send configuration files to Pi
• Download logs from Pi
• Transfer scripts and programs
• No SSH/SFTP needed

Use Case 4: Guest Network Sharing

Scenario: Share files with visitors without network access.

Setup:

1. Deploy PairDrop with HTTPS
2. Create temporary room codes
3. Share room code with guests

Usage:

• Guest connects to guest Wi-Fi
• Opens PairDrop, joins room code
• Shares files without accessing main network
• Room code expires after session

---

Integration Ideas

Home Assistant Integration

Monitor PairDrop status in Home Assistant:

configuration.yaml:

binary_sensor:
  - platform: rest
    name: PairDrop Status
    resource: http://192.168.1.100:3000
    method: GET
    scan_interval: 60
    value_template: '{{ value_json is defined }}'

QR Code Displays

Generate QR codes for easy access:

Digital displays:

Create auto-refreshing webpage with QR code:

<!DOCTYPE html>
<html>
<head>
    <title>PairDrop Access</title>
    <style>
        body { text-align: center; padding: 50px; font-family: Arial; }
        img { width: 300px; height: 300px; }
    </style>
</head>
<body>
    <h1>Scan to Share Files</h1>
    <img src="https://api.qrserver.com/v1/create-qr-code/?size=300x300&data=http://drop.yourdomain.com" alt="QR Code">
    <p>Or visit: <strong>drop.yourdomain.com</strong></p>
</body>
</html>

NFC Tags

Program NFC tags with PairDrop URL for tap-to-open:

1. Get NFC tags
2. Use NFC Tools app (Android/iOS)
3. Write URL record: http://drop.yourdomain.com
4. Tap tag to open PairDrop instantly

---

Alternatives and Comparisons

PairDrop vs. SnapDrop

SnapDrop (original project):

• Public instance: snapdrop.net
• Basic functionality
• Less active development

PairDrop (fork with improvements):

• Room codes for privacy
• Persistent device names
• Better mobile experience
• Active development

Recommendation: Use PairDrop for self-hosting.

PairDrop vs. Other Solutions

LocalSend:

• Native apps (not web-based)
• No server required
• Better for offline use
• More complex setup

Warpinator (Linux Mint):

• Linux-specific
• Built into Linux Mint
• LAN-only
• No web interface

ShareDrop:

• Cloud-based (not self-hosted)
• Similar UI to PairDrop
• Privacy concerns (third-party)

FileBrowser:

• Different use case (file management)
• Requires authentication
• More features, more complexity

Recommendation: PairDrop for instant, simple P2P sharing on mixed devices.

---

Conclusion

You now have a fully functional PairDrop deployment enabling instant file sharing across all your devices.

Key Takeaways:

1. Universal: Works on any device with a web browser
2. Simple: Zero configuration required on client devices
3. Private: Files transfer directly peer-to-peer
4. Fast: Local network speeds, no cloud bottleneck
5. Lightweight: Runs on minimal hardware resources

Next Steps:

• Set up HTTPS for full WebRTC functionality
• Create room codes for organized sharing
• Add DNS records for easy access (e.g., drop.local)
• Configure PWA on mobile devices
• Share with family/team members

Related Guides:

• FileBrowser: Web-Based File Management
• Syncthing: Continuous File Synchronization
• Nextcloud: Full-Featured Cloud Platform

Welcome to seamless cross-platform file sharing!

---

Guide Version: 1.0 Last Updated: January 15, 2025 Tested With: PairDrop v1.10.x Estimated Read Time: 20-25 minutes Estimated Implementation Time: 20 minutes

Part of the homelabbing.io File Sharing & Transfer series