Build a Remote SDR Server with Raspberry Pi and RTL-SDR: rtl_tcp, SpyServer, and Web Waterfall

An RTL-SDR dongle is cheap and capable, but tethering it to a laptop parked next to a window defeats half the point of software-defined radio — reception quality lives and dies by antenna placement, not by where you happen to be sitting. Running the dongle on a headless Raspberry Pi instead turns it into a remote SDR server: the Pi and antenna live wherever reception is best (an attic, a window, outdoors under a weatherproof enclosure), and any laptop or phone on the network can tune, waterfall, and decode signals over the network as if the dongle were plugged in locally. This project covers building that server with rtl_tcp for raw IQ streaming, SpyServer for a more capable multi-client setup, and a simple web-based waterfall for browser access with no client software at all.

Why Remote the SDR

• Antenna placement matters more than almost anything else in SDR reception — a dongle stuck in a laptop USB port in the middle of a room is working with a badly compromised antenna position no matter how good the software is.
• A headless Pi can sit anywhere power and network reach, letting the antenna go somewhere genuinely good (high, away from noisy electronics, with a clear view of the sky for satellite work) independent of where the operator is comfortable sitting.
• Multiple people or devices can share one dongle — SpyServer in particular supports multiple simultaneous clients tuned to different frequencies from the same physical receiver.

Base Pi Setup

1. Flash Raspberry Pi OS Lite (headless, no desktop) to the microSD card — a full desktop environment adds nothing to a machine that will run entirely as a network service.
2. Enable SSH and configure WiFi (or plan on wired Ethernet) during imaging using Raspberry Pi Imager's advanced options, following this site's headless setup guide if starting from scratch.
3. Boot the Pi, SSH in, and run a full update: sudo apt update && sudo apt full-upgrade -y.
4. Blacklist the kernel's built-in DVB-T drivers, which will otherwise claim the RTL-SDR dongle as a TV tuner before the SDR software can use it:
   echo -e "blacklist dvb_usb_rtl28xxu\nblacklist rtl2832\nblacklist rtl2830" | sudo tee /etc/modprobe.d/blacklist-rtl.conf
   then reboot.

Installing rtl-sdr Tools

1. Install build dependencies: sudo apt install -y git cmake build-essential libusb-1.0-0-dev
2. Build the standard rtl-sdr package from source for the latest fixes:
   git clone https://github.com/rtlsdrblog/rtl-sdr-blog cd rtl-sdr-blog mkdir build && cd build cmake ../ -DINSTALL_UDEV_RULES=ON make -j4 sudo make install sudo cp ../rtl-sdr.rules /etc/udev/rules.d/ sudo ldconfig
3. Plug in the dongle and confirm it's recognized: rtl_test -t should report a tuner type and sample rate without errors.

Option A: rtl_tcp for Simple Raw Streaming

rtl_tcp streams raw IQ samples over the network to a single client — SDR#, GQRX, or SDR++ running on another machine connect to it exactly as if the dongle were local.

1. Run rtl_tcp -a 0.0.0.0 -p 1234 to bind on all network interfaces.
2. Set it up as a systemd service so it survives reboots and disconnects gracefully rather than needing a manual SSH session kept open:

FileContents /etc/systemd/system/rtltcp.service[Unit]
Description=rtl_tcp SDR server
After=network.target

[Service]
ExecStart=/usr/local/bin/rtl_tcp -a 0.0.0.0 -p 1234
Restart=always
User=pi

[Install]
WantedBy=multi-user.target

Enable and start it with sudo systemctl enable --now rtltcp. On the client machine, open SDR# or SDR++, choose the RTL-TCP (network) source, and enter the Pi's IP address and port 1234.

Option B: SpyServer for Multi-Client Access

SpyServer (from the Airspy project, also supports RTL-SDR) is a better fit than plain rtl_tcp when more than one client needs to connect at once, since it handles per-client tuning and bandwidth allocation from a single hardware receiver.

1. Download the SpyServer binary for ARM from the Airspy downloads page (spyserver ships as a standalone binary, no compilation needed).
2. Create a config file setting the device type to rtlsdr and the desired sample rate, then run ./spyserver spyserver.config.
3. Set up a matching systemd service following the same pattern as the rtl_tcp example above, pointing ExecStart at the spyserver binary and config file.
4. On the client, SDR++ and SDR# both support a native SpyServer source — enter the Pi's IP and the SpyServer port (default 5555) and multiple people can each tune independently to different parts of the spectrum the dongle is receiving.

Option C: Browser-Based Waterfall (No Client Software)

For quick access from a phone or any browser without installing SDR client software, OpenWebRX turns the Pi into a self-contained web SDR:

1. Install via the official OpenWebRX Docker image (simplest path on a Pi): sudo apt install -y docker.io, then sudo docker run -d --device /dev/bus/usb --restart=always -p 8073:8073 --name openwebrx-rtlsdr openwebrx/openwebrx-rtlsdr
2. Browse to http://<pi-ip>:8073 from any device on the network — no client install required, and multiple browser tabs can each tune independently within the configured band profile.
3. Configure band profiles (frequency ranges, default demodulation modes) through the OpenWebRX admin interface to match what the connected antenna is actually good at receiving.

Network and Security Notes

• Don't expose these ports directly to the internet without a plan — rtl_tcp and SpyServer have no authentication built in. For remote access beyond the local network, put the Pi behind this site's Tailscale or WireGuard VPN setup rather than forwarding ports on the router.
• Assign the Pi a static local IP or DHCP reservation so client configurations (SDR# saved profiles, OpenWebRX bookmarks) don't break after a router reboot.

Safety

If mounting the antenna outdoors or at height, follow standard antenna installation safety — keep well clear of overhead power lines, ground the antenna mast/feedline per local electrical code, and use a proper weatherproof enclosure and cable entry for anything left outside long-term, the same considerations covered in this site's guide to designing weatherproof enclosures.

Once the Pi is running headless with rtl_tcp, SpyServer, or OpenWebRX, the physical dongle effectively disappears — reception quality is set once by antenna placement, and every subsequent listening session is just opening a client and tuning in from wherever's convenient, which is a genuinely different experience from SDR tethered to a single desk.