Jellyfin: How to Build Your Own Streaming Server

⏱️ Reading time: 14 min

Netflix, Disney+, and Spotify cost a fraction in India of what they cost in Europe or Latin America. That’s what one developer experienced: after moving back from living there, he refused to pay Western prices and canceled all his streaming subscriptions.

📑 En este artículo

1. TL;DR
2. What Is Jellyfin?
3. Why a Self-Hosted Streaming Server Makes Sense
4. How It Works Under the Hood
5. Practical Examples
6. Getting Started
7. Real-World Use Cases
8. Common Mistakes and Best Practices
9. Comparison with Alternatives
10. Going Deeper
11. Frequently Asked Questions
    1. Is Jellyfin really free?
    2. Do I need to know how to code to build my own streaming server?
    3. Can Jellyfin completely replace Netflix?
    4. What sets Jellyfin apart from Plex?
    5. Can I access Jellyfin from outside my home?
12. References

Instead, he built his own self-hosted streaming server with Jellyfin: free, open-source software that organizes movies, shows, and music like Netflix, but running on his own network. The case, published on his blog on October 10, 2026, is the perfect excuse to explain what Jellyfin is and how to set it up step by step.

TL;DR

• Jellyfin organizes your own movies, shows, and music with a Netflix-like interface, with no monthly subscription.
• A Mini PC with an Intel N100 and 16 GB of RAM can serve video to an entire family without getting overloaded.
• Docker installs the server with a single command on Linux, macOS, and Windows, without touching system dependencies.
• Real-time transcoding adapts the video so any TV or phone can play it without stuttering.
• Official apps for Android TV, iOS, Roku, and the browser access the library from anywhere via VPN.

What Is Jellyfin?

Jellyfin is a free, open-source media server that organizes your movies, shows, and music, and streams them through a web interface, mobile apps, and TV apps similar to Netflix. It works as a self-hosted streaming server: you control the catalog, the access, and the data, without depending on any external provider.

The project was born in 2018 as a fork of Emby, after that software closed its source code and started charging for features that used to be free. Since then, the official Jellyfin documentation describes it as a 100% free project, with no ads and no telemetry, maintained by a community of volunteers on GitHub.

It runs on Linux, Windows, macOS, inside Docker or Podman, on a NAS with Unraid or TrueNAS, and even on a Raspberry Pi for small libraries. That portability made Jellyfin the preferred home streaming platform for a large part of the self-hosting community, because it doesn’t require a cloud account to work and all processing happens on the user’s own network.

Why a Self-Hosted Streaming Server Makes Sense

The original blog’s motivation wasn’t just price: it was control. The author wanted to limit what his son watched to a fixed catalog, but every streaming service reshuffles its “recommended for you” and “up next” menus with each update. Keeping parental controls current across four different apps is almost a part-time job.

With Jellyfin, the catalog is exactly what you uploaded. There’s no autoplay dragging you to other content, and no recommendation algorithm deciding what’s next. When an episode ends, Jellyfin stops: there’s no “next episode” countdown five seconds later pushing you to keep watching.

Three other reasons come up repeatedly in the self-hosting community. The first is no longer depending on a catalog that changes without notice: a movie available on a service today can disappear next month because a licensing deal expired. The second is privacy, since a self-hosted server doesn’t send viewing habits to any advertiser. The third is simple operational continuity: nobody raises the plan’s price or forces an app redesign every six months.

None of these three reasons solve the problem of legally obtaining content. Jellyfin doesn’t come with a catalog; it only organizes and streams files the user already owns, whether from their own DVDs, legal downloads, or their own productions. That distinction separates Jellyfin from a streaming service of dubious origin, and it’s the same one the project’s own documentation emphasizes.

How It Works Under the Hood

Jellyfin follows a classic client-server architecture. The server runs on a machine on the local network (a Mini PC, a NAS, or a home server) and exposes a REST API on port 8096. Clients, whether TV apps, phones, or the browser, connect to that API to request the catalog and the stream for each file.

When the server starts, it scans the folders configured as libraries and looks up metadata: cover art, synopsis, cast, and rating, using external providers like TheMovieDB or TheTVDB. That’s why file naming conventions matter: a folder like “Show (2024)/Season 01/Show – S01E01.mkv” identifies itself automatically, while a generic name like “final_video.mkv” forces you to match the file manually.

flowchart TD
    A["Client: TV, phone, or browser"] -->|"LAN or WireGuard VPN"| B["Jellyfin Server"]
    B --> C["Library on disk"]
    B --> D["Transcoding engine"]
    B --> E["Metadata: TMDb and TVDb"]

The trickiest part of the design is deciding how to deliver each file. If the video format is already compatible with the requesting device, Jellyfin sends it as-is, untouched: that’s called direct play and it doesn’t use any CPU. If the container isn’t compatible but the video codec is, Jellyfin only swaps the container (direct stream). If neither the container nor the codec is compatible, full transcoding kicks in: the server decodes the original video and re-encodes it in real time into a format the client understands.

sequenceDiagram
    participant C as Client
    participant S as Jellyfin Server
    participant D as Disk
    C->>S: requests to play an episode
    S->>D: reads the video file
    alt The format is compatible with the client
    S-->>C: sends the file unmodified (direct play)
    else The format is not compatible
    S->>S: transcodes to H.264 in real time
    S-->>C: sends the transcoded stream
    end

Transcoding is the most CPU-expensive operation, and that’s exactly where hardware comes in. An Intel N100 like the one described in the original blog includes a built-in video decoder (Quick Sync) capable of transcoding several 1080p streams without overloading the processor, as long as Jellyfin has permission to use it.

Practical Examples

The first step is to spin up the container with the official image. This command is enough for a minimal installation on Linux:

docker run -d \
  --name jellyfin \
  -p 8096:8096 \
  -v $HOME/jellyfin/config:/config \
  -v $HOME/jellyfin/cache:/cache \
  -v $HOME/Videos:/media \
  jellyfin/jellyfin:latest

This command pulls the jellyfin/jellyfin image, publishes port 8096 on the host, and mounts three folders: one for configuration, another for the transcoding cache, and another with your own videos. The output of docker ps confirms it’s up:

CONTAINER ID   IMAGE                     PORTS                    NAMES
3f9a1c7b2e41   jellyfin/jellyfin:latest  0.0.0.0:8096->8096/tcp   jellyfin

For production, it’s worth using a docker-compose.yml with automatic restart and, if the server has an integrated Intel GPU, with the /dev/dri device passed to the container so transcoding uses Quick Sync instead of the CPU:

version: "3.8"
services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    restart: unless-stopped
    ports:
      - "8096:8096"
    volumes:
      - ./config:/config
      - ./cache:/cache
      - /home/usuario/Videos:/media
    devices:
      - /dev/dri:/dev/dri

The restart: unless-stopped directive makes Jellyfin come back up automatically after a server reboot, and devices gives it direct access to the CPU’s video decoder. Once it’s running, the admin dashboard (Control Panel > Playback) lets you enable hardware acceleration and choose which decoders to use.

Jellyfin also exposes a documented REST API, the same one used by projects like Sonarr and Radarr to tell the server to scan a recently updated folder, instead of waiting for the periodic scan.

Getting Started

Before installing anything, you’ll need: Docker Engine running (on Linux, the official installation guide covers every distribution), a folder with at least one of your own videos, and about 2 GB of free RAM beyond whatever the rest of the system uses.

1. Install Docker. On Linux, follow the official guide for your distribution. On macOS and Windows, install Docker Desktop: the docker run command below is identical on all three systems, only the folder paths change (on Windows, something like C:\Users\usuario\Jellyfin\config instead of $HOME/jellyfin/config).
2. Create the folders. One for configuration, another for cache, and point the third to wherever you already keep your videos.
3. Run the container with the docker run command from the previous section.
4. Open your browser at http://localhost:8096 (or the server’s IP if you’re accessing it from another device on the network) and complete the setup wizard: language, admin user, and the first library.

To confirm the server is actually up, docker logs jellyfin should show a line like [INF] Kestrel is listening on "http://[::]:8096". If that line doesn’t appear after a few seconds, the container failed to start, and it’s worth checking the full log before touching the network configuration.

⚠️ Heads up: the original blog avoids exposing any service directly to the Internet, Jellyfin included, and only accesses it from outside through his own VPN. An open port 8096 facing the public Internet is one of the most common compromise vectors in self-hosting setups, because Jellyfin isn’t designed to handle traffic from strangers.

Real-World Use Cases

• Family library with kids’ profiles: each user has their own visible catalog, and Jellyfin can hide entire libraries per profile, without relying on parental controls that rearrange their menus with every app update.
• Remote access behind a VPN: with WireGuard or Tailscale running on the router, any device authenticated on the VPN sees the server as if it were on the local network, without exposing port 8096 to the public.
• Integration with Sonarr and Radarr: these tools automatically download new episodes and movies and notify Jellyfin through its API to add them to the library without waiting for the scheduled scan.
• Archiving your own DVDs and Blu-rays: tools like Automatic Ripping Machine convert physical discs into digital files that Jellyfin catalogs just like any other video.
• Live TV and DVR: with an over-the-air or cable tuner connected to the server, Jellyfin can work as a program guide and recorder, similar to what Kodi did with a PVR plugin.

Common Mistakes and Best Practices

• Exposing port 8096 to the Internet without a VPN: it’s the fastest way for an automated scan to find the server. Use WireGuard, Tailscale, or an authenticated tunnel before accessing it from outside.
• Not passing the GPU to the container: without the /dev/dri device mounted, every transcode falls entirely on the CPU, and a modest Mini PC runs out of breath with just two simultaneous streams.
• Naming files haphazardly: the metadata scraper depends on the Title (Year) convention for movies and Show - SxxExx for series. A name that breaks that convention forces you to match each item manually.
• Forgetting to back up /config: that’s where the database with users, playback history, and library configuration lives. Losing that folder without a backup means rebuilding everything from scratch, even though the video files stay intact.
• Mixing Docker and Podman without checking the syntax: the commands are nearly identical (podman run instead of docker run), but Podman runs containers without a central daemon, so some networking flags behave differently depending on the distribution.

Comparison with Alternatives

Going Deeper

The difference between direct play, direct stream, and full transcoding isn’t just technical: it determines how many simultaneous users the same hardware can support. An H.264 file inside an MP4 container almost always reaches a modern phone through direct play, without using any CPU. The same file in an MKV container with forced subtitles might only need a container swap (direct stream). But a file in an old codec like MPEG-2, or in 4K HDR heading to a device that doesn’t support HDR, forces a full transcode, the most resource-intensive operation.

That’s why hardware acceleration matters so much. Without it, each 1080p transcode can tie up an entire CPU core. With an Intel N100’s Quick Sync decoder enabled, a dedicated block of silicon handles the same task, leaving the CPU free for the rest of the system. The trade-off is that not every codec has acceleration: newer formats like AV1 are only just starting to get full hardware support on mid-range CPUs.

For secure remote access, the most common practice in the community isn’t opening port 8096 to the public, but setting up a WireGuard-style VPN on the router (the same approach the original blog uses) or using a mesh like Tailscale, which connects devices without opening any port on the firewall. An HTTPS reverse proxy, like Caddy or Nginx, adds another layer if you really need to expose the service, but it’s still preferable to restrict access to the VPN first.

A lesser-known feature is SyncPlay: it synchronizes playback across multiple users connected to the same server, letting them watch a movie at the same time from different locations, with play, pause, and seek controls synced across all clients.

💭 Key takeaway: Jellyfin doesn’t replace Netflix’s catalog, it replaces the software that organizes it. The content still has to come from the user.

Your next step: install Jellyfin with the docker run command from the “Getting Started” section on a folder with two or three of your own videos, and complete the setup wizard to see your first library ready in under ten minutes.

Frequently Asked Questions

Is Jellyfin really free?

Yes. It has no premium tier and no features locked behind a paywall: all the code is published under a GPL license on GitHub, and the project is sustained by community donations.

Do I need to know how to code to build my own streaming server?

No. Copying and pasting the docker run command from this article, and completing the web setup wizard, is enough for a working installation. Knowing some command line helps, but it’s not required.

Can Jellyfin completely replace Netflix?

It replaces the way you organize and watch content, not the catalog. Jellyfin only streams files the user already has: their own movies, ripped DVDs, or their own productions, not Netflix-licensed shows.

What sets Jellyfin apart from Plex?

The main one is the model: Jellyfin is 100% free and doesn’t require a cloud account, while Plex requires a Plex account and charges for some advanced features, like easy remote access, through Plex Pass.

Can I access Jellyfin from outside my home?

Yes, but the recommended way isn’t opening port 8096 to the public. A VPN like WireGuard or a mesh like Tailscale lets you connect from anywhere without exposing the server directly to the Internet.

References

• Official Jellyfin documentation: installation guides, library configuration, and transcoding.
• Jellyfin repository on GitHub: source code, GPL license, and the project’s issue tracker.
• Jellyfin on Wikipedia: history of the Emby fork and the project’s timeline.
• What I Self-Host: the original blog documenting the use case and the Beelink S12 Pro hardware.
• Official Docker installation guide: steps to install Docker Engine on every Linux distribution.
• Jellyfin REST API reference: interactive documentation of the available endpoints.

📱 Enjoy this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.

Featured image: Foto de Tyler en Unsplash