How to Install Jellyfin Media Server on Linux Mint 21 or 20

Jellyfin is a free and open-source media server that allows users to stream their media files, such as movies, TV shows, music, and photos, from anywhere with an internet connection. It can be installed on various operating systems, including Linux, Windows, and macOS, making it accessible to a broad user base.

One of the primary reasons for Jellyfin’s popularity is its commitment to being open-source, meaning the code is freely available for anyone to inspect and modify. This approach fosters a community of developers constantly working to improve and expand the software’s capabilities. Additionally, Jellyfin is compatible with a wide range of devices, including smart TVs, mobile devices, and game consoles, making it easy to access media on virtually any device.

Jellyfin is often compared to other media servers software, such as Plex, Emby, and Kodi. While these programs share some similarities, Jellyfin stands out for several reasons. Unlike Plex and Emby, which have commercial versions with additional features, Jellyfin is completely free and open-source. Additionally, unlike Kodi, which requires users to manage their media library manually, Jellyfin automatically detects and categorizes media files, making it much easier for many people.

Jellyfin features a demo server that enables users to test the software before installing it. This guide demonstrates how to install Jellyfin on Linux Mint 21 or Linux Mint 20 and includes instructions for configuring media drives with the necessary read-and-write access. Additionally, the guide covers how to stream media through an Apache or Nginx reverse proxy option for secure remote access and obtaining a Let’s Encrypt Free SSL certificate for enhanced security of web applications.

Step 1: Update Linux Mint

Before installing the Jellyfin Media server on your Linux Mint operating system, ensuring that all packages are up to date is essential. Updating your operating system will ensure that all current packages are up to date and can help prevent any compatibility issues with Jellyfin.

To update your Linux Mint operating system, open the terminal and run the following command:

sudo apt update && sudo apt upgrade

This command will update all the packages on your system to their latest versions, ensuring that your system is up to date.

Step 2: Install Dependecies

After updating your Linux Mint operating system, you will need to install the necessary packages required for the installation of the Jellyfin Media server. Depending on your Linux Mint distribution and version, the required packages may vary.

To install the required packages, open the terminal and run the following command:

sudo apt install software-properties-common apt-transport-https ca-certificates curl

This command will install the necessary packages, which include apt-transport-https, ca-certificates, gnupg2, and curl.

The apt-transport-https package allows Linux Mint to download packages over HTTPS, which ensures that packages are downloaded securely. The ca-certificates package contains SSL certificates that validate the authenticity of websites, ensuring that you only download packages from trusted sources. The gnupg2 package helps verify downloaded packages and ensures that they haven’t been tampered with, while curl is a command-line tool that can download files from the internet.

Running the above command is recommended, even if you’re unsure whether you already have these packages installed. The command won’t cause any harm to your system, and if you already have the packages installed, the command will skip the installation process for those packages.

Step 3: Install Jellyfin Media Server

To install the Jellyfin Media Server on Linux Mint, you’ll need to import the Jellyfin GPG key and repository since the software isn’t available in the default repository. This process ensures the package is authentic and hasn’t been tampered with.

First, import the GPG key by running the following command in the terminal:

curl -fsSL https://repo.jellyfin.org/ubuntu/jellyfin_team.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/jellyfin.gpg

This command downloads the GPG key from the Jellyfin website and adds it to your system’s keyring, allowing you to verify the package’s authenticity during installation.

Next, import the stable or unstable Jellyfin repository. The stable repository is recommended for most users since it’s thoroughly tested and stable. To import the stable repository, use one of the following commands:

Import JellyFin stable repository:

Import JellyFin Media Server stable for Linux Mint 21 distribution series:

echo "deb [arch=$( dpkg --print-architecture ) signed-by=/usr/share/keyrings/jellyfin.gpg] https://repo.jellyfin.org/ubuntu jammy main" | sudo tee /etc/apt/sources.list.d/jellyfin.list

Import JellyFin Media Server stable for Linux Mint 20 distribution series:

echo "deb [arch=$( dpkg --print-architecture ) signed-by=/usr/share/keyrings/jellyfin.gpg] https://repo.jellyfin.org/ubuntu focal main" | sudo tee /etc/apt/sources.list.d/jellyfin.list

Import JellyFin unstable repository:

Alternatively, you can import the unstable repository using the following commands. Note the unstable repository requires FFMpeg 5.

Import JellyFin Media Server unstable for Linux Mint 21 distribution series:

echo "deb [arch=$( dpkg --print-architecture ) signed-by=/usr/share/keyrings/jellyfin.gpg] https://repo.jellyfin.org/ubuntu jammy unstable" | sudo tee /etc/apt/sources.list.d/jellyfin.list

Import JellyFin Media Server unstable for Linux Mint 20 distribution series:

echo "deb [arch=$( dpkg --print-architecture ) signed-by=/usr/share/keyrings/jellyfin.gpg] https://repo.jellyfin.org/ubuntu focal unstable" | sudo tee /etc/apt/sources.list.d/jellyfin.list

Once you’ve added a new software repository, you must update your system’s repository listing to recognize the new additions. To do this, run the following command in the terminal:

sudo apt update

After running the sudo apt update command, your system’s repository listing will be updated to include the newly added repository. This update ensures that Linux Mint recognizes the new repository and its contents, allowing you to install the Jellyfin Media Server on your system.

Step 4: Install Jellyfin

Now that you’ve imported the Jellyfin repository and GPG key, it’s time to install the media server on your Linux Mint system. The installation process is simple and can be completed using the following command:

sudo apt install jellyfin

After the installation is complete, the Jellyfin service will be automatically started. To check the status of the Jellyfin service, use the following command:

systemctl status jellyfin

Example output:

If for any reason, the Jellyfin service fails to start, you can manually start it using the following command:

sudo systemctl start jellyfin

To ensure that the Jellyfin service starts automatically during system boot, run the following command:

sudo systemctl enable jellyfin

These commands will ensure that the Jellyfin service is started and will start automatically during system boot.

Step 5: Jellyfin Media Server Initial Setup

To access the Jellyfin Web UI, you need to open your internet browser and enter the IP address of your server, followed by the default port 8096. If you’re accessing the Jellyfin server on the same machine installed, use 127.0.0.1 as the IP address.

For instance, you can type the following address into your browser’s address bar to access the Jellyfin Web UI:

Example below:

http://127.0.0.1:8096

Upon entering the above address, you’ll be directed to the welcome screen for the initial server setup. This setup screen provides the necessary steps to configure Jellyfin for first-time use:

Example of the welcome screen:

Pin

During the initial setup of your Jellyfin server, you’ll be asked to choose your preferred display language within the Jellyfin interface. Once you’ve made your selection, click on the “Next ->” button to move on to the next step.

After selecting your preferred display language, you’ll be prompted to create a username and password for your Jellyfin account. This account will provide you with administrative access to the Jellyfin server, allowing you to manage media libraries, user accounts, and server settings.

It’s crucial to create a strong and unique password that includes a combination of uppercase and lowercase letters, numbers, and symbols to ensure the security of your Jellyfin server. Once you’ve created your username and password, click on the “Next ->” button to proceed to the next step of the initial server setup.

Example of creating username and password:

Pin

After creating your Jellyfin account, the next step in setting up your server is to configure your media libraries. Media libraries allow you to add your media content to Jellyfin and organize it in a structured manner. You can create multiple libraries for different media types, such as movies, TV shows, and music.

Example of media libraries:

Pin

To organize and display your media content in Jellyfin, you need to add your media content to your media libraries. You can do this by clicking the big “+” or “Add Media Library” button from the Jellyfin dashboard, which will take you to the Media Library setup screen where you can add your media folder.

Adding your media content to Jellyfin is straightforward, and users familiar with Plex will find the process quite similar. Once you’ve selected the “Add Media Library” button, you can choose the media type you wish to add, such as movies, TV shows, or music, and follow the prompts to add your media folder. Additionally, you can specify the metadata language for your media content, which is used to provide information such as episode descriptions, actor biographies, and album artwork.

By adding your media libraries, you can efficiently organize and browse your media content in Jellyfin. Once you’ve added your media libraries, you can proceed to the next step by clicking the “Next ->” button. The next screen is the Metadata Language screen, which allows you to select your preferred language for the metadata of your media content. This information enriches your media content with information such as cast and crew details, plot summaries, and reviews.

Example of preferred metadata language:

Pin

Once you’ve set up your media libraries and selected your preferred metadata language, the next step is configuring remote access to your Jellyfin media server. Remote access allows you to access media content outside your local network, such as from a different location or device.

To enable remote access, you can allow remote connections to your Jellyfin media server and enable automatic port mapping. By allowing remote connections, you can access your media content from anywhere with an internet connection. Automatic port mapping ensures that the ports are opened to allow incoming traffic to reach your Jellyfin server.

For users unfamiliar with port mapping, automatic port mapping is the process of redirecting traffic from one network port to another. By enabling automatic port mapping in Jellyfin, incoming traffic is redirected to the correct port on your local network, allowing you to access your media content remotely. This process is crucial for accessing your media content securely, ensuring that unauthorized users cannot access your media files or network.

Example of configuring remote access:

Pin

After completing the initial setup of your Jellyfin media server, the next screen will confirm that the installation process is finished and your server is ready to use.

Example of initial setup complete:

Pin

Once you have accessed the Jellyfin Web UI, enter the username and password you created during the initial setup process, then click on the “Sign in” button. You will be directed to the Jellyfin dashboard, where you can access your media libraries and manage your content.

Example of Jellyfin sign-in screen:

Pin

Once you log in to your Jellyfin media server, you’ll have access to the dashboard where you can manage your media libraries, users, and server settings. Here are some actions you can perform from the dashboard:

• Add more media content: You can add more media content to your Jellyfin server by clicking on the “Add Media Library” button and selecting the media type you want to add, such as movies, TV shows, or music. You’ll need to provide the necessary information such as the library’s name, location of the media files, and any specific settings for the media type.
• Configure customizations: You can customize the look and feel of your Jellyfin server by configuring customizations such as theme, language, and metadata. Click on the “Dashboard” button, then select “General” or “Display” settings to make changes.
• Manage users: You can add, remove, and modify user accounts to manage access to your media content. Click on the “Users” button on the dashboard, then select “Add User” or “Edit User” to make changes.

Here are some general tips for managing your Jellyfin media server:

• Keep it updated: Regularly check for updates and install them as they become available to ensure your server is up to date.
• Use plugins and extensions: You can use plugins and extensions to add additional functionality to your Jellyfin server, such as support for subtitles or remote control.

By following these steps, you can create a comprehensive media server that provides an excellent viewing experience for all your media content.

Pin

Troubleshoot: Reset the Initial Setup

If you run into any issues during the initial setup of your Jellyfin media server or need to start over for any reason, resetting the setup process is a straightforward process. By modifying the “IsStartupWizardCompleted” value in the system.xml file and restarting the Jellyfin server, you can reset the initial setup process and begin again. Here are the steps to follow:

Open the system.xml file: You can do this by running the following command:

sudo nano /etc/jellyfin/system.xml

This command will open the system.xml file in the nano text editor, which will allow you to make changes to the file.

Modify the “IsStartupWizardCompleted” value:

<IsStartupWizardCompleted>true</IsStartupWizardCompleted>

And change it to:

<IsStartupWizardCompleted>false</IsStartupWizardCompleted>

This change resets the initial setup process, allowing you to start again from the beginning.

To restart the Jellyfin server, run the following command:

sudo systemctl restart jellyfin

Restart the setup process: Once you’ve restarted the Jellyfin server, you can revisit the HTTP://127.0.0.1:8096 and restart the setup process.

Step 6: Setup Permissions for Media Drives

After installing Jellyfin on your Linux Mint system, it is important to set up the necessary permissions for the media server to access and read your media directories. This can be done using the setfacl command, which provides more detailed control over access compared to the chown and chgrp commands.

Before proceeding with setting up permissions, ensure that you have the ACL package installed by running the following command:

sudo apt install acl

To give Jellyfin access to your media directory and all its subdirectories, use the following command with the -R (recursive) flag:

sudo setfacl -R -m u:jellyfin:rx /media/mymediadrive

If you need to assign permissions to individual media directories or files, use the following command:

sudo setfacl -m u:jellyfin:rx /media/mymediadrive/example-name-of-file-or-directory

Additional Commands & Tips

Configure SSH

If you plan to access your Linux Mint Jellyfin Media Server remotely, it is essential to set up a Secure Shell (SSH) tunnel. SSH is a protocol for secure remote login and other secure network services over an insecure network.

To configure SSH on your Linux Mint server, follow these steps:

Install the SSH server on your Linux Mint machine using the following command:

sudo apt install openssh-server

Once the SSH server is installed, you can connect to your Jellyfin Media Server remotely using an SSH tunnel. Replace {server-ip-address} with your server’s IP address and enter the following command in your terminal:

ssh {server-ip-address} -L 8096:localhost:8096

This command creates an SSH tunnel for the Jellyfin Media Server.

After creating the SSH tunnel, you can access the Jellyfin Media Server through the following link in your web browser:

http://localhost:8096/web/index.html#/wizardstart.html

Please note that through an SSH tunnel, the HTTP request will be redirected to http://localhost:8096/web, which is the remote server. Once the initial setup is complete, you can access your Jellyfin Media Server using your remote server IP address at https://{server-ip-address}:8096.

Configure UFW Firewall

Configuring the UFW firewall is crucial for managing incoming and outgoing network traffic on your Linux Mint server. Unlike Ubuntu, the UFW firewall is not enabled by default in Linux Mint, so it must be enabled manually. By enabling the UFW firewall, users can ensure that only necessary traffic is allowed to their server.

To enable the UFW firewall, you can use the following command in the terminal:

sudo ufw enable

Once enabled, it is important to allow incoming traffic on port 8096, which is required for Jellyfin Media Server to function properly. To allow incoming traffic on port 8096, use the following command:

sudo ufw allow 8096

This command will allow incoming traffic on port 8096 to your server, ensuring that Jellyfin Media Server can function correctly.

For users who do not have UFW installed, the following command can be used to install it:

sudo apt install ufw

Setup Apache or Nginx as a Reverse Proxy

Setting up a reverse proxy for Jellyfin can help you access the media server from a remote computer or network.

Setting up Apache as a Reverse Proxy

If you want to access your Jellyfin media server from a remote computer or network, you can set up a reverse proxy using Apache or Nginx. Here the guide will cover how to set up Apache as a reverse proxy on Linux Mint.

First, install the Apache web server using the following command:

sudo apt install apache2

By default, Apache should be enabled, but if it is not, you can enable it using the following command:

sudo systemctl start apache2

Next, use a text editor to create a new virtual host configuration file for Jellyfin. For example, you can use the nano editor as follows:

sudo systemctl enable apache2

Next, enable the necessary modules with the following command:

sudo a2enmod proxy proxy_http headers proxy_wstunnel

Create a new virtual host configuration file for Jellyfin using the following command:

sudo nano /etc/apache2/sites-available/jellyfin.conf

To create a subdomain, you must have an active domain name. One option for purchasing a domain name is through NameCheap, where domains are available for as little as $1 to $2. Alternatively, if you prefer a .com domain, you can use Cloudflare.

Once you have created your subdomain, you can set up a virtual host with Apache by following these steps:

<VirtualHost *:80>
    ServerName jellyfin.example.com

    # Redirect HTTP to HTTPS
    Redirect permanent / https://jellyfin.example.com

    ErrorLog /var/log/apache2/jellyfin-error.log
    CustomLog /var/log/apache2/jellyfin-access.log combined
</VirtualHost>

<IfModule mod_ssl.c>
<VirtualHost *:443>
    ServerName jellyfin.example.com

    DocumentRoot /var/www/html/jellyfin/public_html

    ProxyPreserveHost On

    ProxyPass "/socket" "ws://localhost:8096/socket"
    ProxyPassReverse "/socket" "ws://localhost:8096/socket"

    ProxyPass "/" "http://localhost:8096/"
    ProxyPassReverse "/" "http://localhost:8096/"

    SSLEngine on
    SSLCertificateFile /etc/letsencrypt/live/jellyfin.example.com/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/jellyfin.example.com/privkey.pem
    Protocols h2 http/1.1

    SSLCipherSuite HIGH:RC4-SHA:AES128-SHA:!aNULL:!MD5
    SSLHonorCipherOrder on

    SSLProtocol all -SSLv2 -SSLv3 -TLSv1 -TLSv1.1

    ErrorLog /var/log/apache2/jellyfin-error.log
    CustomLog /var/log/apache2/jellyfin-access.log combined
</VirtualHost>
</IfModule>

Save the file (CTRL+O), then exit (CTRL+X).

To ensure that there are no errors in the Apache configuration or virtual host file before enabling the virtual host, you can perform a “dry run” using the following command:

sudo apache2ctl configtest

After checking the Apache configuration syntax for any syntax errors using the previous command, you can proceed to enable the virtual host using the following command:

sudo a2ensite jellyfin.conf

By creating a symbolic link from the sites-available directory to the sites-enabled directory, the previous command enabled the virtual host to be served by Apache. Once the virtual host is enabled, it is necessary to restart Apache to apply the changes. This can be done by running the following command:

sudo systemctl restart apache2

The command stops and starts the Apache service, applies the new virtual host settings, and reloads the configuration with the updated changes.

Setting up Nginx as a Reverse Proxy

Nginx can be a reverse proxy to enable remote access to your Jellyfin media server. Nginx is a lightweight and high-performance web server commonly used for this purpose.

To install Nginx, use the following command:

sudo apt install nginx

Next, start the Nginx service using the following command:

sudo systemctl start nginx

To ensure that Nginx is enabled, run the following command:

sudo systemctl enable nginx

This command starts the Nginx service and ensures that it starts automatically at boot time.

Example output if successful:

Synchronizing state of nginx.service with SysV service script with /lib/systemd/systemd-sysv-install.
Executing: /lib/systemd/systemd-sysv-install enable nginx

To check the status of Nginx, use the following command:

systemctl status nginx

Once you have confirmed that Nginx is running correctly, you can proceed to create a new server block file at /etc/nginx/conf.d/jellyfin.conf. In this example, we will use the subdomain jellyfin.example.com.

sudo nano /etc/nginx/conf.d/jellyfin.conf

To configure Nginx as a reverse proxy, you need to set up a server block file at /etc/nginx/conf.d/jellyfin.conf with the following directives:

• The listen directive sets the port and address that Nginx should listen on. For this example, port 80 is used.
• The server_name directive: This sets the hostname or domain name that Nginx should listen to. Replace jellyfin.example.com with your domain name.
• The access_log and error_log directives: These set the locations for the access and error logs.
• The location directives: These define how Nginx should handle incoming requests.

The location directives configure the proxy_pass, which will forward requests from Nginx to Jellyfin. The proxy_pass sets the protocol and address of the upstream server, the Jellyfin server, and is set to listen on port 8096. The location directive specifies how Nginx should handle incoming requests and can handle requests for the root URL (/), requests for the /web/ directory, and requests for the /socket directory.

Here is an example server block file:

server {
    listen 80;
    server_name jellyfin.example.com;

    access_log /var/log/nginx/jellyfin.access;
    error_log /var/log/nginx/jellyfin.error;

    set $jellyfin jellyfin;
    resolver 127.0.0.1 valid=30;

    # Security / XSS Mitigation Headers
    add_header X-Frame-Options "SAMEORIGIN";
    add_header X-XSS-Protection "1; mode=block";
    add_header X-Content-Type-Options "nosniff";

    location = / {
        return 302 https://$host/web/;
    }

    location / {
        # Proxy main Jellyfin traffic
        proxy_pass http://$jellyfin:8096;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Protocol $scheme;
        proxy_set_header X-Forwarded-Host $http_host;

        # Disable buffering when the nginx proxy gets very resource heavy upon streaming
        proxy_buffering off;
    }

    # location block for /web - This is purely for aesthetics so /web/#!/ works instead of having to go to /web/index.html/#!/
    location = /web/ {
        # Proxy main Jellyfin traffic
        proxy_pass http://$jellyfin:8096/web/index.html;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Protocol $scheme;
        proxy_set_header X-Forwarded-Host $http_host;
    }

    location /socket {
        # Proxy Jellyfin Websockets traffic
        proxy_pass http://$jellyfin:8096/socket;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Protocol $scheme;
        proxy_set_header X-Forwarded-Host $http_host;
    }
}

Save the file (CTRL+O), then exit (CTRL+X).

It is important to verify that the configuration for Nginx as a reverse proxy for Jellyfin is error-free before proceeding. To do this, a dry run can be executed using the following command:

sudo nginx -t

This command will test the configuration file for syntax errors and other issues. If everything is working correctly, the output should show that the configuration file is ok and the test is successful, as follows:

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

To apply the changes to Nginx, you need to reload the service. You can do this by running the following command:

sudo systemctl reload nginx

After properly configuring Nginx as a reverse proxy for Jellyfin and setting up your domain and DNS records to point to your server IP, you can now access your Jellyfin Media Server at jellyfin.example.com. With Nginx acting as the intermediary, remote users can now access Jellyfin by visiting the subdomain, and Nginx will direct their requests to Jellyfin’s web interface.

Create Let’s Encrypt SSL Free Certificate

In this section, we will guide you on how to secure your Apache or Nginx server using a Let’s Encrypt SSL free certificate. Using an SSL certificate ensures that the communication between the user’s browser and the server is secure, making it an ideal way to run your server on HTTPS.

To install the certbot package, you need to match the reverse proxy you have installed. If you’re using Apache, you need to install python3-certbot-apache, and if you’re using Nginx, you need to install python3-certbot-nginx.

Install Certbot for Apache:

sudo apt install python3-certbot-apache

Install Certbot for Nginx:

sudo apt install python3-certbot-nginx

To secure the Apache or Nginx with a Let’s Encrypt SSL Free Certificate, you need to install the certbot package that matches the reverse proxy you have installed. If you’re using Apache, install python3-certbot-apache, and for Nginx, install python3-certbot-nginx.

Once installed, run the certbot command to create a certificate. The command has options like –apache or –nginx, depending on your reverse proxy, as well as –agree-tos, –redirect, –hsts, and –staple-ocsp. These options help set up 301 redirects, a Strict-Transport-Security header, and OCSP Stapling, making it a secure setup. Remember to replace the email and domain name with your own requirements.

Run Certbot for Apache and Jellyfin:

sudo certbot --apache --agree-tos --redirect --hsts --staple-ocsp --email you@example.com -d jellyfin.example.com

Run Certbot for Nginx and Jellyfin:

sudo certbot --nginx --agree-tos --redirect --hsts --staple-ocsp --email you@example.com -d jellyfin.example.com

After creating the SSL certificate, the user’s URL will change from HTTP to HTTPS. To ensure the certificate is automatically renewed, the user can set up a cron job that checks it daily. Certbot provides a script that can automatically renew the certificate. Before setting up the cron job, the user should test the script by running a dry run with the following command:

sudo certbot renew --dry-run

After confirming the successful dry run, the user can set up a cron job to automate the certificate renewal process. To do this, the user can use the following command:

sudo crontab -e

This command opens the user’s cron table in edit mode. Next, the user can add the following line to the end of the file to schedule a daily renewal check at 2:30 am:

30 2 * * * /usr/bin/certbot renew --quiet

Once the user saves and exits the file, cron will automatically check the certificates daily and renew them if necessary.

Update Jellyfin Media Server

To update your Jellyfin Media Server, you can use the standard apt commands, just like you would for any other package on your system. This makes updating Jellyfin a simple process.

To check for updates, run the following command:

sudo apt update

If there are any updates available, run the upgrade command:

sudo apt upgrade

Remove (Uninstall) Jellyfin Media Server

To uninstall Jellyfin from your system, you can use the following command:

sudo remove install jellyfin --purge

To ensure that you don’t accidentally reinstall Jellyfin in the future, removing the Jellyfin repository from your system is recommended. You can use the following command to remove it:

sudo rm /etc/apt/sources.list.d/jellyfin.list

This command will remove the repository file for Jellyfin from the sources.list.d directory, preventing future updates or installations of Jellyfin.

Conclusion

In conclusion, setting up a media server can seem daunting, but with Jellyfin and Linux, it can be done easily and efficiently. Jellyfin is a free, open-source media server that offers a wide range of features, making it an ideal choice for anyone looking to set up a media server. In this guide, we have covered various aspects of setting up a Jellyfin media server, including installing it on Linux Mint, configuring the firewall, setting up Apache or Nginx as a reverse proxy, securing the server with an SSL certificate, updating the software, and removing it from your system. Following these steps, you can easily set up a Jellyfin media server and access your files from anywhere in the world. With the flexibility and features offered by Jellyfin and the power and reliability of Linux, you can create a media server that suits your needs and preferences.

FAQs on Jellyfin Media Server on Linux Mint