How to transfer files to Linux from Windows 10 over SSH

If you’ve ever emailed yourself a file just to move it from Windows 10 to a Linux box, this article is your friendly intervention.
SSH-based transfers are faster, more secure, andonce you set them upalmost boring. (Boring is good. Boring means it works.)
Below is a practical, real-world guide to moving files from Windows to Linux over SSH using SCP, SFTP, and
rsync, plus a couple of GUI options for days when you’d rather drag-and-drop than type-and-pray.

SSH, SCP, and SFTP: the “same tunnel, different vehicles” explanation

SSH (Secure Shell) is the encrypted connection. Think of it as the secure tunnel between your Windows PC and the Linux machine.
On top of that tunnel you can:

• SCP (Secure Copy): quick, command-line file copies. Great for “send this file/folder over there.”
• SFTP (SSH File Transfer Protocol): a full file-transfer protocol over SSH, with browsing and file management.
• rsync over SSH: the efficiency nerdexcellent for large folders or repeated syncs because it copies only changes.

The best part: all of these use the same SSH authentication and encryption, so you’re not shipping files in plain text like it’s 1999.

Before you transfer: make sure Linux is actually listening for SSH

File transfer over SSH only works if your Linux machine is running an SSH server (usually sshd).
Many servers already have it; many desktops don’tespecially fresh installs.

1) Install the SSH server (if needed)

Ubuntu/Debian:

Fedora/RHEL/CentOS (modern):

2) Allow SSH through the firewall

UFW (common on Ubuntu):

firewalld (common on RHEL/Fedora):

3) Confirm the basics: IP/hostname, username, and port

You’ll need:
(a) the Linux machine’s IP address or hostname,
(b) a username on that Linux machine, and
(c) the SSH port (default is 22, but many servers change it).

Option 1 (Recommended): Use Windows 10’s built-in OpenSSH tools

Modern Windows 10 includes OpenSSH as an optional feature (and on many systems it’s already installed). Once it’s there,
you can use ssh, scp, and sftp right from PowerShell or Command Promptno extra apps needed.

Step A: Check/install OpenSSH Client on Windows 10

On Windows 10, go to Settings → Apps → Optional features and look for OpenSSH Client.
If it’s missing, install it.

PowerShell install method (Admin):

Step B: Test SSH first (don’t skip this)

Before moving files, confirm you can actually log in:

The first time you connect, Windows will ask you to trust the server’s host key.
That’s normal. Read it, accept it, move on with your life.

Step C: Copy a single file with SCP

Here’s a classic “Windows Downloads → Linux home folder” copy. In PowerShell:

Tip: If your path has spaces, always quote it. SCP is powerful, but it’s not psychic.

Step D: Copy a folder with SCP (-r)

Useful SCP flags (the “save me later” list)

• -P 2222 → use a custom SSH port (capital P)
• -i C:pathtokey → use a specific private key file
• -p → preserve timestamps (handy for scripts and sanity)
• -C → compression (helpful on slower links)
• -v → verbose output for troubleshooting

Example with port + key:

Common Windows-path gotcha: the colon problem

SCP uses a colon (:) to separate host:path. Windows drive letters also use colons (C:).
That’s why quoting Windows paths is not optionalit’s how you prevent SCP from thinking your drive letter is a hostname.
If something looks like ssh: C: Name or service not known, it’s almost always a path-parsing issue.

Option 2: Use SFTP when you want “FTP vibes” without the insecurity

SFTP runs over SSH, but behaves more like a file-transfer session: you can browse directories, upload, download,
and run multiple transfers without reconnecting each time.

Interactive SFTP from Windows Terminal/PowerShell

Then use commands like:

SFTP batch mode (quietly awesome for repeat tasks)

Create a text file called batch.txt like this:

Then run:

If you’re doing recurring uploads (logs, backups, exports), SFTP batch mode is a clean middle ground between “one-off SCP”
and “full automation project that somehow becomes your personality.”

Option 3: Rsync over SSH for large folders and repeat syncs

SCP is great for simple copies, but it’s not built for “keep these two folders in sync.”
That’s where rsync shines: it can copy only what changed, preserve metadata, and resume more gracefully.
The catch: Windows doesn’t ship with rsync nativelyso you typically run rsync from WSL (Windows Subsystem for Linux),
or you install a Unix-like environment that includes it.

The easiest rsync approach on Windows 10: use WSL

If you already have WSL set up, you can run Linux rsync locally and push files to your Linux machine over SSH.
Example (from WSL shell):

Want a safety preview first?

Use rsync when you’re transferring thousands of files, re-running transfers daily, or moving large datasets where “start over”
would ruin your afternoon.

Option 4: GUI tools that still use SSH under the hood

Command-line tools are greatuntil you’re trying to grab three files from three folders and your brain is running on coffee fumes.
GUI clients can be faster for humans. The important detail: choose a client that uses SFTP over SSH.

WinSCP (popular Windows SFTP/SCP client)

• Great for drag-and-drop transfers
• Good session management (save host/user/port)
• Useful when you don’t want to memorize flags

FileZilla (use SFTP, not plain FTP)

• Make sure the protocol is set to SFTP
• Works well for basic uploads/downloads
• Helpful for non-technical users on your team

SSH keys: the upgrade your future self will thank you for

Password logins workbut SSH keys are faster, safer, and friendlier to automation.
On Windows, you can generate keys with OpenSSH tools and then install the public key on the Linux server.

Generate a key on Windows

This creates a private key (keep it secret) and a public key (safe to share with the server).
If you set a passphrase, you’ll get better security, and you can use an agent to avoid typing it constantly.

Add your public key to Linux

One simple method is to copy the public key contents and append it to Linux’s authorized keys:

Paste the contents of your Windows public key (usually id_ed25519.pub) into authorized_keys, save, exit.
Then try:

Once keys work, you can consider tightening security by limiting password authentication on the server
(but only after you’ve verified key login, unless you enjoy locking yourself out as a hobby).

Troubleshooting: the greatest hits (and quick fixes)

“Permission denied (publickey)”

• You’re using key auth, but the server doesn’t have your public key installed in ~/.ssh/authorized_keys.
• Check permissions: ~/.ssh should be 700, and authorized_keys should be 600.
• Try specifying the key explicitly: ssh -i C:pathtokey username@host

“Connection timed out” or it just hangs

• Wrong IP/hostname, wrong port, or firewall blocking.
• Test port reachability: try ssh -v username@host to see where it fails.
• Confirm sshd is running on Linux: systemctl status ssh or systemctl status sshd.

“Host key verification failed” (or a scary warning about changed keys)

• This happens if the server was rebuilt/reinstalled, or you’re connecting to a different machine at the same IP.
• Verify you’re connecting to the correct host (security matters here).
• If it’s legit, remove the old entry from your Windows known_hosts file and reconnect.

Uploads go to the wrong place

• Use absolute paths on Linux (e.g., /home/username/incoming/).
• Remember: ~ expands to the remote user’s home directory, but only if your shell interprets it.

Windows path weirdness

• Always quote Windows paths, especially with spaces or drive letters.
• When in doubt, run SCP/SFTP from the directory you want and reference files relatively.

Security and best practices (quick, practical, not preachy)

• Prefer SSH keys over passwords for anything repeatable.
• Use a non-root user and only elevate privileges when needed.
• Keep SSH updated on your Linux server, especially on internet-exposed machines.
• Consider changing the port only if it fits your security model (it reduces noise, not risk, by itself).
• For frequent transfers, rsync over SSH is usually the most efficient.

From the trenches: of real-world transfer experience

Here’s what tends to happen in real life: you start with one file, you feel powerful, and then suddenly you’re migrating an entire
directory tree named Final_Final_ReallyFinal_ThisOne and wondering why nothing is where you expected it to be. So, let’s talk about
the lessons people learn the “fun” waymeaning after the first mild disaster.

Lesson 1: Always SSH first. If your login doesn’t work, your transfer won’t work. Testing with
ssh username@host saves time because it forces you to confirm the right username, host, port, and authentication method up front.
When you skip this, SCP errors feel vague, and you start blaming the network, the firewall, and maybe the moon.

Lesson 2: Quote your Windows paths like your paycheck depends on it. Windows paths contain spaces and colons.
SCP uses colons to separate the host from the remote path. That means a lazy unquoted C:Stuff can get interpreted as
“connect to host C.” (Spoiler: host C is not responding.) Quoting the path makes Windows-to-Linux transfers dramatically less dramatic.

Lesson 3: SCP is a sprinter, rsync is a marathon runner. For a one-time upload, SCP is perfect. For repeated transfers
(daily logs, photo archives, project folders), SCP becomes that friend who insists on re-telling the entire story every time.
Rsync, on the other hand, remembers what changed and transfers only the difference. The first time you sync 80 GB and then re-run the job
and it finishes in minutes, you will have a small moment of joy. Treasure it.

Lesson 4: When permissions break, they break loudly. Linux cares deeply about file permissions, especially in
~/.ssh. If your SSH key setup fails, it’s often because authorized_keys permissions are too open.
The server is basically saying, “If anybody can edit your key file, I’m not trusting this circus.” Set
~/.ssh to 700 and authorized_keys to 600, and a surprising number of problems vanish.

Lesson 5: Use SFTP/GUI tools when you’re exploring, not when you’re automating. WinSCP or a GUI SFTP client is fantastic
for browsing, grabbing a couple of files, or confirming where something lives on the server. But for repeatable workflows, scripting wins.
A small PowerShell script using scp or a WSL script using rsync will outlive your memory of “which folder was it in again?”

Lesson 6: Write down your “working command.” The command that finally workscorrect port, correct key, correct pathshould be
saved somewhere. Put it in a notes file, a password manager note, or a README in your project. Because future-you will not remember whether it
was -P 2222 or -p 2222, and present-you deserves better than that.

Conclusion

To transfer files from Windows 10 to Linux over SSH, you have three excellent lanes:
SCP for fast one-offs, SFTP for interactive sessions and batch transfers, and rsync over SSH
for big folders and repeat syncs. Start simple: install Windows OpenSSH Client, confirm you can SSH in, then use SCP or SFTP.
Upgrade to SSH keys when you’re ready to make the process faster, safer, and easier to automate.

SEO Tags