Relayium vs scp: simpler file transfer over SSH

Last updated: 2026-07-12

scp has been the default way to move a file over SSH for decades: it's on almost every Unix-like machine already, everyone knows the syntax, and it just works. There's no reason to pretend otherwise — scp earned its place.

Relayium's CLI doesn't replace SSH; it rides on top of the exact same SSH access you already have. push and pull use your SSH connection the same way scp does, but add a few things scp was never built to do: resuming a broken transfer, verifying every file with a checksum, showing real progress, and working even when the remote has nothing installed at all.

Where scp is genuinely simpler

It's worth saying plainly: for a lot of jobs, scp is the right tool and adding anything else is overhead.

It's already installed — no binary to fetch, nothing to set up, on effectively every server you'll ever SSH into.
It's battle-tested. Decades of use, well-understood behavior, and every sysadmin already knows the flags.
For a genuine one-off — copy this one file, right now — typing scp file.txt user@host:path is less typing than installing anything.
It's ideal for quick, throwaway scripting where you don't want a dependency beyond OpenSSH.

Before you start

Everything below is the relayium CLI, so install it first if you haven't. On macOS or Linux, one command drops a prebuilt binary on your PATH:

curl -fsSL https://relayium.com/install.sh | sh

Prefer to pick the file yourself, or on Windows? Grab a binary from the releases page — relayium.com/cli lists every install option (or go build -o relayium ./cmd/relayium if you have Go).
relayium --version confirms it's installed. Skip this and the commands below just print 'command not found'.

push / pull: the same SSH, with resume, checksums and progress

relayium push and relayium pull connect over the identical SSH access scp uses — same host, same key, same port. The difference is what happens once the connection is open.

Every file is verified end to end with a SHA-256 hash after it arrives, so a transfer that looks done actually matches what was sent, byte for byte. If a transfer is interrupted — a dropped connection, a closed laptop lid — restarting the same command picks up from where it left off instead of resending everything, and you see real per-file progress the whole way, not a silent copy.

The biggest practical difference is what happens when the remote doesn't have relayium installed. push checks for it automatically and, if it isn't there, falls back to streaming a plain tar archive over the same SSH connection into tar -x on the other end — so push still works against a completely bare server, nothing to install first. That fallback is push-only: pull always needs relayium already installed on the remote, because on a pull the remote machine is the one acting as the sender.

relayium push ./photos user@your-server:backups/

relayium pull user@your-server:backups/ ./restore

Beyond SSH: daemon-direct and cross-network pairing

scp only ever works where you have SSH access. Relayium's CLI adds two more ways to move files that scp has no equivalent for.

relayium serve turns a machine you own into a daemon-direct target reachable over pinned TLS 1.3 — no SSH, no port 22, trust established on the first connection (approved interactively, or pre-authorized with relayium authorize for unattended use) and pinned from then on. Push straight to it with a relayium:// address.

For sending to someone across the internet who you don't have SSH access to at all, relayium send / receive pairs two computers with a short code instead — direct peer-to-peer, with an optional short verification code (SAS) both sides can compare first — --verify stops for it. scp has no answer for that case; you'd need SSH access first.

relayium push ./build relayium://your-server

relayium send ./report.pdf

Folder mirroring: sync vs re-running scp -r

Copying a whole directory again and again with scp -r means re-sending everything every time, with no notion of what changed or what should be removed. relayium sync builds an incremental one-way mirror on top of push/pull or daemon-direct: only changed files move, --delete removes files on the destination that disappeared from the source, and --watch keeps re-syncing in real time as files change locally — no cron job needed.

relayium sync ./photos user@your-server:backups/photos --delete --watch

Feature comparison at a glance

The differences that matter most, side by side:

Availability: scp is preinstalled on virtually every server; Relayium's CLI is a single binary you install once with one command.
Resume: scp restarts an interrupted transfer from scratch; push/pull resume from where they stopped.
Integrity: scp doesn't verify contents after the fact; every Relayium transfer is checked with a per-file SHA-256 hash.
Bare servers: scp needs nothing extra, and push works the same way via its tar fallback when relayium isn't installed remotely (pull needs relayium on the remote, no fallback).
Beyond SSH: scp only works over SSH; Relayium also offers daemon-direct (pinned TLS, no SSH) and cross-network pairing-code transfers (send/receive) that need no SSH access at all.
Folder mirroring: scp -r re-sends everything; relayium sync mirrors incrementally with --delete and --watch.
Cost and license: both free; scp ships with OpenSSH, Relayium's CLI is AGPL-3.0-licensed and open source.

Frequently asked questions

Does Relayium's CLI need an account?

Not for push/pull — it uses your own SSH access exactly like scp does, with no Relayium account and no sign-in, and the same goes for daemon-direct and sync. send and cloud up are the exceptions: send needs an account so the server can mint its pairing code (one given a code you were handed does not), and up needs one to store the file. Receiving never needs one.

Does push work if the remote server doesn't have Relayium installed?

Yes. push checks first and, if relayium isn't there, falls back to a plain tar stream over the same SSH connection so it still works against a bare server. That fallback is push-only — pull always needs relayium already installed on the remote, since the remote acts as the sender in a pull.

Is it really as simple as scp to use?

The commands look the same: relayium push src user@host:dest instead of scp -r src user@host:dest. The difference only shows up when something goes wrong — a dropped connection resumes instead of restarting, and every file is checksum-verified on arrival.

When should I just use scp instead?

For a genuine one-off copy where nothing needs to resume, nothing needs verifying, and you don't want any extra binary — scp is already there and is the simpler pick. It's also the safer default inside quick scripts where you don't want a new dependency.

Is Relayium's CLI free?

Yes, completely — no paid tier, AGPL-3.0-licensed and open source, and every mode connects the two ends directly.

Install the free Relayium CLI and try push or pull over the SSH access you already have.

Get the CLI