A practical guide to building a self-hosted media server on a Raspberry Pi, with your own movie and TV library streamable to phones, tablets, laptops, smart TVs, and Chromecast — at home or on the road.
A practical guide to building a self-hosted media server on a Raspberry Pi, with your own movie and TV library streamable to phones, tablets, laptops, smart TVs, and Chromecast — at home or on the road.
A Raspberry Pi running Jellyfin (a free, open-source media server) that:
Jellyfin is the main recommendation because it's free, runs entirely on your hardware, and doesn't require an account on anyone's server. If you'd rather have the slickest UI and the easiest remote-access setup and don't mind a vendor account, Plex is a drop-in alternative; almost everything in this guide applies, just with Plex's installer and apps instead.
Hardware
On your network
Estimated cost: roughly USD $80–150 plus storage, depending on what you already own.
Use Raspberry Pi OS Lite (64-bit). No desktop — this is a headless server.
raspberrypi.com/software on your laptop.mediapi (or whatever you like)Give it about a minute to boot, then from your laptop:
ssh [email protected]
If .local doesn't resolve on your network, find the Pi's IP in your router's admin page and SSH to that instead. Once in, update everything:
sudo apt update && sudo apt full-upgrade -y
sudo reboot
Plug your external drive into a USB 3.0 port (the blue ones on a Pi 4; any USB 3 port on a Pi 5). SSH back in after reboot.
Find the drive:
lsblk -f
You'll see something like sda1 with a filesystem type (ext4, exfat, or ntfs). For a media library that lives on the Pi long-term, ext4 is the best choice — fastest and most reliable on Linux. If the drive was formatted on Windows or Mac, you can either keep it as is (install the right driver) or reformat it (which erases everything).
If you need NTFS or exFAT support, install drivers first:
sudo apt install -y ntfs-3g exfatprogs exfat-fuse
Create a permanent mount point and auto-mount the drive on boot:
sudo mkdir -p /mnt/media
sudo blkid /dev/sda1 # note the UUID
sudo nano /etc/fstab
Add a line at the bottom (replace YOUR-UUID and adjust the filesystem type):
UUID=YOUR-UUID /mnt/media ext4 defaults,nofail,x-systemd.device-timeout=10 0 2
For NTFS use ntfs-3g instead of ext4; for exFAT use exfat. Save (Ctrl+O, Enter, Ctrl+X), then:
sudo mount -a
ls /mnt/media
If you see your files (or an empty folder for a fresh drive), you're set. The nofail option means the Pi won't refuse to boot if the drive is unplugged — useful.
Jellyfin (and Plex, and basically every media server) finds posters, plot summaries, and episode info by matching folder and file names to online databases. Get the naming right and everything Just Works; get it wrong and you'll be manually fixing metadata for hours.
Create this structure on /mnt/media:
/mnt/media/
├── Movies/
│ ├── The Matrix (1999)/
│ │ └── The Matrix (1999).mkv
│ └── Inception (2010)/
│ └── Inception (2010).mp4
└── TV Shows/
├── Breaking Bad/
│ ├── Season 01/
│ │ ├── Breaking Bad - S01E01.mkv
│ │ ├── Breaking Bad - S01E02.mkv
│ │ └── ...
│ └── Season 02/
└── Severance/
└── Season 01/
Rules that save grief:
Title (Year). The year disambiguates remakes.SxxEyy notation. S01E01, not 1x01 or episode 1.You can transfer files to the Pi over the network. The easiest way is to set up Samba (Windows file sharing) so the drive appears as a network folder on your laptop:
sudo apt install -y samba
sudo nano /etc/samba/smb.conf
Add to the bottom:
[media]
path = /mnt/media
browseable = yes
read only = no
guest ok = no
valid users = mediapi
force user = mediapi
Set a Samba password (can match your login password):
sudo smbpasswd -a mediapi
sudo systemctl restart smbd
On Windows, open File Explorer and type \\mediapi.local\media. On macOS, in Finder, Go → Connect to Server and enter smb://mediapi.local/media. Drag your files in.
The Jellyfin team maintains an official Debian repo, so installation is one script:
curl https://repo.jellyfin.org/install-debuntu.sh | sudo bash
When it asks for the architecture and OS version, accept the defaults it detects. After it finishes:
sudo systemctl status jellyfin
You should see active (running) in green. From any computer on the same network, open a browser to:
http://mediapi.local:8096
The Jellyfin setup wizard will walk you through:
/mnt/media/Movies/mnt/media/TV ShowsJellyfin will start scanning your library. With a few hundred items it takes a couple of minutes; with thousands, leave it overnight. You can browse the UI while it works.
A Raspberry Pi's CPU is not strong enough to transcode 1080p video on the fly. Its GPU, however, can — if you tell Jellyfin to use it.
Why this matters: If a client device can play your file natively (right codec, right resolution, right container), Jellyfin just sends the bytes — easy. If the device can't (wrong codec, too big a file for a phone's screen, slow connection), Jellyfin has to re-encode in real time. Without hardware acceleration, the Pi tries to do this with the CPU and produces a slideshow.
Add the Jellyfin user to the video and render groups so it can use the GPU:
sudo usermod -aG video,render jellyfin
sudo reboot
Then in the Jellyfin web UI:
Test by playing something. In the player, click the gear → Quality → pick a lower bitrate to force a transcode. CPU usage should stay reasonable; if the Pi fan ramps up to a roar and playback stutters, the GPU isn't actually being used — revisit the encoder settings.
A trick that sidesteps transcoding entirely: keep your library in formats most devices play natively. H.264 video + AAC audio in an MP4 or MKV container plays directly on virtually everything. If you control the encoding (e.g., using HandBrake to rip), this is the path of least pain.
On the same Wi-Fi, everything works immediately. Install the Jellyfin app from your platform's store:
http://mediapi.local:8096In each app, server address is http://mediapi.local:8096 (or the Pi's IP). Log in with the user you created.
Create extra user accounts for family members in Dashboard → Users. Each gets their own watch history, resume points, and library access rules — useful for keeping the kids out of your horror collection.
You have three options, in order of how much I'd recommend them.
Tailscale creates a private mesh network between your devices. Your phone, your Pi, and your laptop all act like they're on the same LAN, even when you're on hotel Wi-Fi in another country. No router config, no exposing your Pi to the open internet, no paying for a static IP.
On the Pi:
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up
It'll print a URL. Open it on your laptop, sign in with Google or Microsoft or GitHub, and the Pi joins your "tailnet." Install the Tailscale app on your phone, sign in with the same account, and now http://mediapi:8096 works from anywhere. Free for personal use (up to 100 devices).
This is the recommended approach. It's secure, it's fast, it doesn't expose anything publicly, and it survives changing IPs.
If you want a real https://media.yourdomain.com URL with a proper certificate and no Tailscale app required on every client, Cloudflare Tunnels do this without opening any router ports. Requires owning a domain and pointing it at Cloudflare. More setup than Tailscale; worth it if you want frictionless access for non-technical family.
You can forward port 8096 on your router to the Pi, optionally with a dynamic DNS service. This exposes Jellyfin directly to the internet, which means: keep it patched religiously, put it behind a reverse proxy with HTTPS (Caddy makes this easy), use strong passwords, and consider fail2ban. If any of those words are unfamiliar, use Tailscale instead.
Automated library management: the *arr stack — Sonarr (TV), Radarr (movies), Prowlarr (indexers), and Bazarr (subtitles) — automates fetching metadata, renaming files into the structure above, and grabbing subtitles in the languages you want. Install via Docker for cleanliness. Be aware that you're responsible for sourcing your own media legally; these tools don't care where files come from.
Hard-drive spindown: if you use a spinning HDD, install hd-idle so it sleeps when idle. Saves power and noise.
Backups: back up /var/lib/jellyfin/ periodically. It contains your library metadata, user accounts, watch history, and settings. Losing it means rescanning everything and starting over — annoying, not catastrophic.
Monitoring: htop shows live CPU/RAM. iotop shows disk I/O. If playback stutters, check both.
A UPS: a small uninterruptible power supply protects the Pi and drive from sudden power loss, which is the most common cause of corrupted SD cards.
"Server not found" in the mobile app. You're on cellular, not your home Wi-Fi. Use the IP or set up Tailscale.
Playback stutters or buffers locally. Almost always either (a) hardware transcoding isn't actually engaged — check the dashboard's "active streams" view, which says "Direct Play," "Direct Stream," or "Transcoding," or (b) the Pi is on Wi-Fi. Wire it.
Metadata is wrong or missing. Folder name doesn't match the rules in section 4, or the year is wrong. Right-click the item in Jellyfin → Identify to fix manually.
Drive disappears after a reboot. Power. Either the drive needs its own power brick, or the Pi's power supply isn't supplying enough. Check dmesg | grep -i usb for under-voltage warnings.
Subtitles don't show. Drop a .srt file with the same base name as the video alongside it (Inception (2010).en.srt), or install Bazarr.
External access stopped working. Your home IP changed. This is why Tailscale is recommended — it doesn't care.
You now have a Netflix-shaped service that costs nothing per month, runs on hardware that fits in a deck of cards, contains exactly what you want it to, and isn't going to remove your favorite show next quarter because of a licensing dispute. Enjoy.