Self-Hosted Alternatives to AirDrop

AirDrop Only Works in Apple’s Walled Garden

AirDrop solves a real problem — send a file to someone nearby without fumbling with email, messaging apps, or USB drives. But it only works between Apple devices. iPhone to Mac? Seamless. iPhone to Windows laptop? Impossible. Android to anything? Not even an option.

Apple’s implementation also has privacy quirks. AirDrop broadcasts a hashed version of your phone number and email over Bluetooth to discover nearby devices. Researchers have demonstrated that these hashes can be reversed to identify users. The “Contacts Only” setting helps, but the discovery mechanism still leaks identifiable data.

If you work across mixed device ecosystems — Windows desktops, Linux servers, Android phones, and iPads — AirDrop’s platform restriction is a dealbreaker. Self-hosted alternatives use standard web technologies (WebRTC, WebSockets) to provide the same instant file-sharing experience on any device with a browser.

Best Alternatives

PairDrop — Best Overall AirDrop Replacement

PairDrop is the closest thing to AirDrop for the rest of the world. Devices on the same network auto-discover each other through the web UI. Select a device, pick your files, and they transfer directly between browsers via WebRTC — files never touch the server. It works on phones, tablets, laptops, and desktops regardless of operating system.

PairDrop improves on AirDrop in several ways: persistent device pairing across sessions, room-based sharing for connecting devices on different networks, text/message sharing alongside files, and a clean web UI that requires zero installation on client devices.

Feature	Apple AirDrop	PairDrop (Self-Hosted)
Cross-platform	Apple only	Any device with a browser
File size limit	None (local transfer)	None (WebRTC, peer-to-peer)
Server required	No (Bluetooth + Wi-Fi)	Yes (signaling server only)
Files touch server	No	No (peer-to-peer via WebRTC)
Auto-discovery	Bluetooth LE	Same network detection
Persistent pairing	Via Apple ID contacts	Yes (cross-session)
Text sharing	No	Yes
Room-based sharing	No	Yes (cross-network)
Installation required	Built into Apple OS	None (web UI)
Privacy	Hashed phone/email broadcast	No personal data exposed
Open source	No	Yes (MIT license)

PairDrop runs as a lightweight Node.js server in Docker. It handles WebRTC signaling and device discovery — actual file data flows directly between browsers. Resource usage is minimal: under 50 MB RAM, negligible CPU.

Best for: Anyone who needs AirDrop-style instant file sharing across mixed device ecosystems. The best drop-in replacement.

[Read our full guide: How to Self-Host PairDrop]

LocalSend — Best Native App Experience

LocalSend is an open-source, cross-platform file sharing app that doesn’t require a server at all. Install it on Windows, macOS, Linux, Android, or iOS, and devices discover each other on the local network using mDNS. Files transfer over HTTPS directly between devices — encrypted in transit, no cloud involved.

Unlike PairDrop (which runs in the browser), LocalSend is a native app. This means better OS integration: share-sheet support on mobile, drag-and-drop on desktop, and transfer speeds closer to the network’s maximum throughput. The trade-off is that every device needs the app installed — you can’t share with someone who hasn’t installed it.

Feature	Apple AirDrop	LocalSend
Cross-platform	Apple only	Windows, macOS, Linux, Android, iOS
Installation	Built-in	App required (open-source)
Server needed	No	No
Discovery	Bluetooth LE	mDNS (local network)
Encryption	Yes	HTTPS (TLS)
File size limit	None	None
Native OS integration	Full (share sheet, Finder)	Good (share sheet, desktop)
Open source	No	Yes (MIT license)

Best for: Teams and households where every device can install the app. Best native experience with zero server infrastructure.

Send — Best for Sharing With Anyone

PairDrop and LocalSend work great when both parties are nearby or on the same network. For sharing files with anyone, anywhere — like emailing a download link — Send is the answer. Upload a file, get an encrypted link with configurable download limits and expiry. Files are end-to-end encrypted in the browser before upload.

Send is closer to a WeTransfer replacement than an AirDrop replacement, but it fills the gap AirDrop leaves for remote sharing. No account required on either end — share the link via any messaging app.

Best for: Sharing files with people who aren’t on your network. Complements PairDrop for remote transfers.

[Read our full guide: How to Self-Host Send]

Feature Comparison

Feature	AirDrop	PairDrop	LocalSend	Send
Transfer type	Local (P2P)	Local (WebRTC P2P)	Local (HTTPS P2P)	Remote (upload/download)
Cross-platform	Apple only	All (browser)	All (native app)	All (browser)
Server required	No	Yes (signaling)	No	Yes (storage)
Files on server	No	No	No	Yes (encrypted)
End-to-end encrypted	Yes	Yes (WebRTC DTLS)	Yes (TLS)	Yes (AES-GCM)
Auto-discovery	Bluetooth	Network detection	mDNS	N/A (link sharing)
File size limit	None	None	None	Configurable
Link sharing	No	No	No	Yes
Text sharing	No	Yes	Yes	No
Installation	Built-in	None	App required	None
Self-hosted	No	Yes	No (serverless)	Yes

Recommended Setup

For complete AirDrop replacement, run both PairDrop and Send:

• PairDrop handles instant local sharing — the “hand someone a file” use case. Runs on minimal resources (signaling server only, no file storage needed).
• Send handles remote sharing — the “send a download link” use case. Needs storage for encrypted files.

Both run easily in Docker on the same VPS. PairDrop uses ~50 MB RAM; Send uses ~150 MB RAM plus storage for uploaded files.

# Quick reference — both services on one machine
PairDrop: pairdrop.yourdomain.com (signaling only, no storage)
Send:     send.yourdomain.com (encrypted file storage)

What You Give Up

• Zero-install experience. AirDrop is built into every Apple device. PairDrop requires opening a URL. LocalSend requires installing an app. There’s always one extra step.
• Bluetooth discovery. AirDrop finds nearby devices even without Wi-Fi. PairDrop and LocalSend require a shared network (though PairDrop’s room feature allows cross-network sharing).
• Share sheet integration. On Apple devices, AirDrop appears in the system share sheet. LocalSend integrates with share sheets on most platforms; PairDrop doesn’t (it’s browser-based).
• Speed on Apple devices. AirDrop uses a combination of Bluetooth and Wi-Fi Direct for transfer speeds up to ~1 Gbps. Browser-based WebRTC transfers are typically slower due to browser overhead.

For mixed-platform environments, the flexibility of PairDrop far outweighs these trade-offs. If your entire household or team is on Apple, AirDrop remains the simplest option — but adding one Android or Windows device makes self-hosted alternatives essential.

FAQ

Can PairDrop transfer files between devices on different Wi-Fi networks?

Yes. PairDrop’s room feature lets you create a temporary room code and share it with someone on a different network. Both devices join the room via the PairDrop web UI, and file transfer works over WebRTC with the server acting as a TURN relay when direct peer-to-peer isn’t possible.

Does PairDrop work without an internet connection on a local network?

PairDrop requires the signaling server to be reachable. If you host PairDrop on a server within your LAN, transfers work without internet since both the signaling server and the file transfer are local. The server just coordinates device discovery — actual files flow peer-to-peer.

What’s the maximum file size PairDrop can handle?

There’s no inherent limit. PairDrop transfers files directly between browsers via WebRTC, so the limit is your device’s available memory and the browser’s WebRTC buffer. In practice, multi-gigabyte transfers work reliably. For very large files (10+ GB), LocalSend’s native app may be more stable than browser-based transfer.

Is LocalSend truly serverless — no Docker container needed?

Correct. LocalSend uses mDNS for device discovery on the local network — no server component whatsoever. Install the app on each device and they find each other automatically. This makes it ideal for users who don’t want to maintain any infrastructure.

Can I use PairDrop to share files with someone who hasn’t installed anything?

Yes, that’s PairDrop’s main advantage over LocalSend. The recipient just opens the PairDrop URL in any browser. No app installation, no account creation. Share the URL, select the recipient’s device, and transfer. This works on phones, tablets, and desktops.

How secure are PairDrop transfers — can my server admin see the files?

Files transfer directly between browsers using WebRTC with DTLS encryption. The PairDrop server only handles signaling (telling devices how to connect to each other). File contents never pass through the server, so even the server administrator cannot intercept transferred files.

Does Send encrypt files before uploading to the server?

Yes. Send performs AES-128-GCM encryption in the browser before uploading. The encryption key is part of the URL fragment (after the #), which is never sent to the server. Even if someone accesses the server’s storage, files are unreadable without the link.

Related

• How to Self-Host PairDrop
• How to Self-Host Send
• PairDrop vs Send
• Best Self-Hosted File Sharing Tools
• Self-Hosted Alternatives to WeTransfer
• Self-Hosted File Transfer Alternatives
• Secure Self-Hosted File Sharing