How to Transfer Files Directly Over the Internet: P2P Without the Cloud, DashBeam

1. The Problem

A familiar situation. You need to send a colleague a 40-gigabyte database dump. WeTransfer complains about the limit. Google Drive syncs for an hour, then fails on quota. Email cuts off the attachment halfway through. And the file is sitting on the desk next to you, literally, your colleague is three meters away.

This is exactly where direct file transfer over the internet comes in: no uploading to someone else’s cloud, no waiting for sync, no accounts or subscriptions. In practice this is P2P: two devices negotiate directly and exchange data between themselves, and if a server is involved at all, it’s only to help them find each other.

We’ll walk through this using DashBeam, an open-source client (formerly AltSendme) built on top of the Iroh P2P stack. We’ll cover why cloud services hit a ceiling, how to set up a P2P transfer in five minutes, what to do when the connection won’t punch through NAT, and how this approach differs from croc, Magic Wormhole, and LocalSend.

Your first send will take about ten minutes. After that, it’s seconds. All you need is DashBeam on both devices and a file you’re tired of waiting on.

At the time of writing, the current version is 0.6.0. Check the latest releases on GitHub before installing, the project moves fast, with releases coming out nearly every month.

2. Why Cloud Doesn’t Cut It

Why doesn’t cloud storage solve the simple task of “just send a file”? Here’s the breakdown.

• Size limits. Free WeTransfer caps out at 2-5 GB, email attachments at 25 MB. A database dump, a log archive, or camera footage simply don’t fit.
• Double transfer time. The file first gets uploaded to a server, then downloaded by the receiver. That’s two trips across the network instead of one, and if your connection is asymmetric, upload is always slower than download.
• Your data passes through someone else’s server. Even with “cloud” encryption, the file physically sits on a third party’s disk, even if temporarily. For internal logs, configs with secrets, or client data, that’s an unnecessary risk.
• You need an account. Registration, email confirmation, daily send limits, extra steps when all you wanted was to send a file.
• No resume on interruption. Upload dies at 90%, start over. When moving large archives over an unstable connection, this gets exhausting.
• File-sharing links don’t last. The link expires in a day or a week, the service shuts down, the domain gets sold. A P2P transfer has none of this problem, because it never leaves the file on a server to begin with.

Quite the request you’ve got there, a cloud service would say, if it could talk, right before timing out on the load balancer’s middleware.

3. The Fix

Prerequisites

Dependencies are minimal, actually one of the reasons DashBeam was picked for this example, rather than something that needs a server and a five-container Docker Compose setup.

• Two devices with internet access (or on the same local network, which is even faster)
• Permission to install an app (admin on Windows/Linux, regular user rights on macOS/Android)
• Outbound traffic allowed, no need to forward inbound ports, explained below

Step 1. Install DashBeam on the sending device

Go to the project’s GitHub releases and download the build for your OS. For Windows, grab the MSI or portable ZIP, for macOS the Universal DMG, for Linux a deb/rpm/AppImage matching your distro.

# Linux (Debian/Ubuntu) - example .deb package install
sudo dpkg -i AltSendme_0.6.0_amd64.deb
sudo apt-get install -f

Result: DashBeam shows up in your app list. On first launch it generates a device cryptographic key (Ed25519), which defines your endpoint’s “identity” in the Iroh network.

Step 2. Install DashBeam on the receiving device

Same procedure on the second device, doesn’t matter if it’s macOS, Android, or Linux. DashBeam is cross-platform, you can send from a phone to a server and back.

# macOS - installing from a mounted DMG
hdiutil attach DashBeam_universal.dmg
cp -R "/Volumes/DashBeam/DashBeam.app" /Applications/
hdiutil detach "/Volumes/DashBeam"

Result: the app is available on both ends of the transfer. No account needed, you’re ready to send files.

Step 3. Send the file

In the DashBeam interface, drag a file or folder into the send window. The app computes a BLAKE3 hash of the content and generates a “ticket”: a string encoding the sender’s endpoint id, connection addresses, and the blob hash.

You can share the ticket any way you like: copy it as text, show a QR code to scan with a camera, send it through the system’s “Share” menu. Then pick one of three routes:

• Send the ticket manually (chat, email, any messenger)
• Send to a device that’s already paired (no ticket copying at all)
• Send to a device found nearby via Nearby (mDNS on the local network)

Step 4. Receive the file on the second device

Paste the ticket into the receive field (or accept the pop-up invite if the devices are already paired). DashBeam shows a preview: what’s coming and how big it is, and only starts downloading after you confirm.

# Example ticket structure (shortened, the real one is longer)
blobtxxxxxxxxx-nodeid-relayurl-hash

Result: the file or folder lands in DashBeam’s system downloads folder, integrity confirmed by matching the BLAKE3 hash.

Step 5. Set up a permanent device pair (optional, but saves time)

If you regularly move files between the same laptop and phone, go to Settings → Devices on both devices and enter the pairing code once. After that, sending is just a “Send” button next to the device name, no ticket copying needed.

How It Works Under the Hood

Iroh, which DashBeam is built on, tries to connect devices directly, and only falls back to a relay as a temporary bridge if that’s not possible. The diagram below skips the protocol details and just shows the packet’s path.

Key point: even when a relay is in the path, it only sees encrypted QUIC traffic. Encryption keys are derived from the ticket, known only to the sender and receiver, the relay never gets them and can’t decrypt the content.

Ports and Network Requirements

Important point: DashBeam doesn’t require configuring port forwarding on your router in the vast majority of cases. Hole punching does its job automatically, roughly the same way it works in WireGuard or Tailscale. If you’re on a corporate network with a strict firewall that blocks all UDP, you’re left with the relay fallback, and speed drops to the relay’s bandwidth.

Security

• Encryption by default. Every transfer runs over QUIC on top of TLS 1.3, keys are tied to a specific ticket and can’t be reused.
• Cryptographic authentication. The ticket contains the sender’s endpoint id, the receiver physically can’t connect to the wrong device.
• One ticket, one transfer. Tickets for paired invites aren’t reused between sends, each one generates a new ticket.
• Keys stored in the system keychain. The device’s secret key lives in Keychain on macOS, Credential Manager on Windows, Secret Service on Linux, not in a plain text file next to the app.
• No telemetry. The developers state directly that no transfer statistics are collected.

4. Verification

After the transfer, confirm everything arrived intact, not “looks about right.”

# Check the checksum of the received file (Linux/macOS)
b3sum received_file.tar.gz
# Compare it with the hash DashBeam showed during sending

# Windows PowerShell - check with the built-in certutil (SHA256, if BLAKE3 isn't available locally)
certutil -hashfile received_file.tar.gz SHA256

Also, inside the app itself: open the transfer history (added in 0.6.0) and check the status, “completed” means the hash matched automatically, the app won’t mark a file as received if integrity wasn’t confirmed.

5. Troubleshooting

Not as bad as it looks. Much simpler, actually, nine times out of ten the fix is either a fresh ticket or turning off VPN for a minute.

6. Alternatives

DashBeam was picked as the main option in this article for three reasons: it’s the only one of the bunch that does desktop, mobile, web, and CLI all at once; transfers resume after a drop (Magic Wormhole and LocalSend don’t do this); and there’s no artificial file size ceiling, unlike PairDrop, which is limited by browser memory.

7. Prevention

• Keep the client updated. The project is active, releases come out almost monthly, security patches arrive with updates rather than separate hotfixes.
• Don’t leave Nearby discovery on by default everywhere. In Settings → Network, switch visibility to “Paired only” when on public networks, this keeps random nearby devices from seeing you in the list.
• Verify the hash for critical files. For database dumps, config backups, and anything heading to production, don’t rely only on the green checkmark in the UI, run b3sum manually.
• Keep background mode enabled only on trusted devices. A constantly active tray process on a shared computer is an extra entry point if outsiders have physical access to the machine.

8. FAQ

Why isn’t file transfer working after setting up DashBeam?

Most often the culprit is UDP getting blocked by a firewall, without it, neither hole punching nor the relay fallback can get through. Check your network settings and try the transfer over mobile data as a test: if it works there but not on your main network, the problem is a corporate or router firewall.

How do I verify a P2P transfer completed correctly?

Compare the BLAKE3 hash of the received file with what the app showed during sending. In the transfer history, a “completed” status means integrity was checked automatically, if the hash doesn’t match, the file is flagged as corrupted, not as received.

What do I do if the ticket isn’t accepted on the other device?

Copy the full ticket string, a truncated ticket won’t parse. If the ticket is correct but the sender’s session already closed (the app was shut before the transfer finished), ask for a new ticket, the old one is dead.

How is DashBeam different from WeTransfer?

WeTransfer uploads the file to the service’s server, and the receiver then downloads it from there, with a size limit and an expiring link. DashBeam connects devices directly, with no intermediate storage on someone else’s server, no limits, and no registration.

9. What’s Next

You’ve installed DashBeam on both devices, run your first transfer, paired the devices, and confirmed hole punching gets through your network without messing with ports. From here, sending a large file is thirty seconds instead of a half-hour upload wait.

Database dumps, log archives, camera footage, all of it goes directly, gets encrypted along the way, and never ends up on someone else’s disk. If after all these steps your transfer still falls back to relay and won’t speed up, leave a comment and we’ll look into your specific case.

Related links:
DashBeam on GitHub
Iroh, the P2P stack behind DashBeam
croc, a CLI alternative
Magic Wormhole
LocalSend
PairDrop