# Comment configurer un serveur Jellyfin ?

Un serveur Jellyfin personnel est une solution pratique si vous souhaitez héberger vous-même vos films, séries, musiques ou photos de manière centralisée. Au lieu de confier vos médias à un service de streaming tiers, vous gardez un contrôle étendu sur vos fichiers, les comptes utilisateurs et les accès, sur tous vos appareils.

## Qu’est-ce que Jellyfin ?

Jellyfin est un serveur multimédia [open source](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-que-lopen-source/) qui vous permet d’**organiser et de cataloguer votre propre collection de médias**, puis de la diffuser en streaming vers différents terminaux via un navigateur Web ou une application. Le logiciel prend en charge les bibliothèques classiques, comme les films, les séries, la musique et les photos. Il propose également une gestion des utilisateurs, des métadonnées, des jaquettes et de la reprise de lecture, ainsi que du streaming sur le réseau.

Comme Jellyfin est autohébergé, le service fonctionne **indépendamment de tout fournisseur externe**. Internet n’est nécessaire que pour certaines fonctions, comme la récupération des métadonnées, les mises à jour, certains plugins ou l’accès externe. Pour l’accès sur le réseau domestique, Jellyfin utilise par défaut le protocole HTTP sur le port 8096, sans qu’il soit nécessaire d’exposer ce port directement sur Internet. De plus, il est possible d’utiliser [HTTPS](https://www.ionos.fr/digitalguide/hebergement/aspects-techniques/le-https-cest-quoi/). Pour l’accès externe, la documentation officielle recommande de passer par un reverse proxy et des certificats de confiance.

## Quelles sont les conditions préalables recommandées pour un serveur Jellyfin ?

Avant d’installer Jellyfin, vous devez d’abord choisir le type de serveur le plus adapté. Pour un serveur Jellyfin, il ne s’agit pas seulement de savoir combien de fichiers vous souhaitez stocker, mais surtout de déterminer si vos appareils peuvent lire directement les fichiers multimédias ou si le serveur doit les convertir pendant la lecture. Cette conversion s’appelle le **transcodage** et elle est particulièrement gourmande en ressources. La 4K, le tone mapping HDR vers SDR et plusieurs flux simultanés peuvent notamment solliciter fortement le [processeur (CPU)](https://www.ionos.fr/digitalguide/serveur/know-how/cpu/) ou le processeur graphique (GPU).

La documentation de Jellyfin recommande, pour des **déploiements moyens**, au moins 8 Go de [mémoire vive (RAM)](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-quune-memoire-vive/) de manière générale. Pour un serveur Linux sans interface graphique, 4 Go peuvent suffire. Jellyfin préconise aussi, pour l’accélération matérielle sur les systèmes non Apple, un GPU Intel, car la configuration et la qualité des encodeurs sont avantageuses en pratique.

Dans ce qui suit, nous vous présentons, à l’aide de quelques scénarios, quel serveur Jellyfin est le plus adapté à votre cas d’usage.

### Particuliers et familles

Si vous utilisez Jellyfin principalement seul ou avec deux ou trois personnes, et que vos fichiers existent déjà dans des [formats vidéo](https://www.ionos.fr/digitalguide/sites-internet/web-design/les-formats-de-fichiers-video/) courants comme le **MP4 avec H.264**, un bon [serveur privé virtuel (VPS)](https://www.ionos.fr/serveurs/vps "VPS | Serveur virtuel pas cher | IONOS France") suffit souvent. Dans ce scénario, le serveur doit généralement seulement distribuer les fichiers, au lieu de les convertir à chaque lecture. À titre de base pratique, vous pouvez prévoir par exemple 4 vCores, 4 Go de RAM et environ 120 Go de stockage NVMe, à adapter selon la taille de votre médiathèque. Si vous souhaitez un peu plus de marge pour les métadonnées, des bibliothèques plus volumineuses et des conversions occasionnelles, 6 vCores, 8 Go de RAM et 240 Go de stockage NVMe constituent une option plus confortable.

L’avantage d’un VPS réside surtout dans son **rapport qualité-prix**. Vous disposez de suffisamment de puissance pour un serveur Jellyfin personnel, sans devoir investir immédiatement dans du matériel dédié. Cette option est particulièrement adaptée lorsque vos terminaux lisent déjà nativement les formats modernes et que le transcodage n’est nécessaire que rarement.

### Utilisateurs avancés

Si vous avez besoin de plus de marge, parce que votre bibliothèque grandit rapidement, que vous souhaitez créer plusieurs comptes utilisateurs ou adapter plus librement les ressources du serveur, les [serveurs Cloud](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-quun-serveur-cloud/) ou les [Cloud Cubes](https://cloud.ionos.fr/compute/cloud-cubes "IONOS CLOUD Cubes | Instances rentables et flexibles") sont des options pertinentes. Les serveurs et Cubes à partir de 4 vCPU, 8 Go de RAM et 240 Go de stockage peuvent être utilisés. Vous disposez ainsi de nettement plus de latitude pour les analyses en parallèle, les métadonnées, les bibliothèques et les transcodages occasionnels.

Le grand avantage de cette variante est sa **flexibilité**. Les serveurs Cloud peuvent être facilement adaptés à l’évolution de vos besoins. C’est pratique si vous commencez petit, mais souhaitez plus tard ajouter plusieurs bibliothèques, davantage d’utilisateurs ou des services supplémentaires comme un [reverse proxy](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-quun-reverse-proxy-le-serveur-reverse-proxy/), du monitoring ou une [sauvegarde](https://www.ionos.fr/digitalguide/serveur/securite/quest-ce-quune-sauvegarde/). Pour les utilisateurs privés avancés, les petites équipes ou les adeptes de « homelab » (environnement informatique personnel pour l’autohébergement), c’est souvent la solution de milieu de gamme la plus confortable.

### Utilisateurs intensifs et amateurs de 4K

Les utilisateurs qui possèdent beaucoup de contenus 4K, souhaitent diffuser du contenu HDR vers des appareils plus anciens ou effectuer plusieurs transcodages simultanés atteignent rapidement les limites d’un petit VPS. Jellyfin souligne explicitement que le **tone mapping HDR vers SDR en mode logiciel peut être extrêmement gourmand en CPU**. Pour de tels scénarios, un [serveur dédié](https://www.ionos.fr/serveurs/serveurs-dedies "Serveurs Dédiés | Hébergement pas cher avec Windows ou Linux | IONOS") ou un [serveur bare metal](https://www.ionos.fr/serveurs/bare-metal-server "Bare metal server pas cher avec Windows ou Linux | IONOS CLOUD") constitue un meilleur choix, car vous y utilisez du matériel dédié et ne partagez **ni puissance de calcul, ni RAM, ni stockage avec d’autres charges de travail**.

Vous devriez ici prévoir un CPU moderne, 16 à 32 Go de RAM, un stockage SSD ou NVMe rapide et, surtout, un GPU adapté au transcodage matériel. L’idéal est de disposer en plus d’un GPU Intel ou NVIDIA adapté au transcodage matériel.

### Recommandation de système d’exploitation : Debian ou Ubuntu ?

Les deux [distributions de serveurs Linux](https://www.ionos.fr/digitalguide/serveur/configuration/distributions-linux-pour-serveur/) conviennent à Jellyfin, mais Ubuntu Server 24.04 LTS est, selon notre expérience, souvent plus pratique pour les débutants. Docker documente officiellement [Ubuntu](https://www.ionos.fr/digitalguide/serveur/know-how/ubuntu-le-systeme-linux-pour-tous/) 24.04, et de nombreux tutoriels se réfèrent directement à Ubuntu. [Debian](https://www.ionos.fr/digitalguide/serveur/know-how/debian-le-logiciel-systeme-universel/) est également très stable, mais Ubuntu vous évite quelques pièges lors de la mise en place.

Conseil Si votre collection de médias grandit très rapidement, un stockage externe peut devenir judicieux. Pour les débutants, les stockages locaux [SSD](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-quun-ssd/) ou NVMe sur le serveur sont idéaux. De plus, un stockage externe comme un [stockage objet](https://www.ionos.fr/digitalguide/serveur/know-how/object-storage/) supplémentaire peut être utilisé, mais doit d’abord être monté sur le serveur comme système de fichiers, par exemple via un outil de montage approprié. Jellyfin accède en effet directement aux fichiers dans le système de fichiers et ne prend pas en charge le stockage objet comme source de stockage native. À titre alternatif, le stockage objet peut aussi servir de stockage d’archives pour les anciens médias qui n’ont pas besoin d’être disponibles en permanence.

## Comment installer Jellyfin avec Docker sur Ubuntu Server ?

Dans l’exemple suivant, nous montrons comment installer Jellyfin sur Ubuntu Server 24.04 LTS avec Docker Engine et le plugin [Docker Compose](https://www.ionos.fr/digitalguide/serveur/configuration/tutoriel-docker-compose/). Cette variante est une bonne solution, en particulier pour les débutants, car Docker isole proprement l’application et simplifie les mises à jour ultérieures.

### Étape 1 : mettre à jour le serveur Ubuntu

Connectez-vous à votre serveur via [SSH](https://www.ionos.fr/digitalguide/serveur/outils/protocole-ssh/) et commencez par mettre à jour les sources de paquets et les paquets installés :

```bash
sudo apt update
sudo apt upgrade -y
```

Vous pouvez ensuite redémarrer le serveur si nécessaire (après un redémarrage, une nouvelle connexion est requise) :

```bash
sudo reboot
```

Cette étape est importante pour commencer avec des paquets à jour, les correctifs de sécurité récents et un système propre. En particulier pour un serveur Ubuntu fraîchement déployé, c’est la toute première action à effectuer.

### Étape 2 : installer Docker sur Ubuntu 24.04

Dans l’étape suivante, vous devez installer Docker sous Ubuntu 24.04. Pour cela, Docker recommande de configurer le [repository](https://www.ionos.fr/digitalguide/serveur/know-how/referentiel/) APT officiel. Commencez par supprimer les paquets plus anciens ou susceptibles d’entrer en conflit :

```bash
sudo apt remove docker.io docker-compose docker-compose-v2 docker-doc podman-docker containerd runc docker-ce-rootless-extras -y
```

Configurez maintenant le repository Docker officiel :

```bash
sudo apt update
sudo apt install ca-certificates curl -y
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF
sudo apt update
```

Installez ensuite Docker Engine, Buildx et le plugin Compose avec la commande suivante dans le terminal :

```bash
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y
```

Vérifiez ensuite si Docker est en cours d’exécution :

```bash
sudo systemctl status docker
```

Le statut doit apparaître comme `active (running)` :

[![Image: Indicateur de statut de Docker](https://www.ionos.fr/digitalguide/fileadmin/_processed_/b/9/csm_jellyfin-docker-active_ed36b0ce76.webp "Indicateur de statut de Docker")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/jellyfin-docker-active.jpg) L’indication « active » confirme que Docker est en cours d’exécution. Il est ensuite judicieux de tester l’installation avec le conteneur de test officiel.

```bash
sudo docker run hello-world
```

La sortie devrait ressembler à ceci :

[![Image: Hello World de Docker](https://www.ionos.fr/digitalguide/fileadmin/_processed_/2/a/csm_jellyfin-docker-hello-world_0a0da78b63.webp "Hello World de Docker")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/jellyfin-docker-hello-world.jpg) Dès que vous voyez le message Hello World, vous pouvez être sûr que Docker n’est pas seulement installé, mais qu’il fonctionne également comme prévu. ### Étape 3 : utiliser Docker sans sudo

Par défaut, les commandes Docker doivent souvent être exécutées avec `sudo`. Si vous le souhaitez, vous pouvez ajouter votre utilisateur au groupe `docker` :

```bash
sudo usermod -aG docker $USER
newgrp docker
```

Note La documentation Docker précise que les membres du groupe docker obtiennent des droits similaires à ceux de root. Pour un serveur personnel, c’est courant, mais vous devez savoir que, dans des applications où d’autres utilisateurs ont accès à votre serveur, cela peut être **problématique du point de vue de la sécurité**.

### Étape 4 : créer la structure de répertoires pour Jellyfin

Après les préparatifs, créez la structure de répertoires du serveur Jellyfin afin de préparer l’installation. Pour que la configuration, le [cache](https://www.ionos.fr/digitalguide/hebergement/aspects-techniques/quest-ce-quun-cache/) et les médias soient clairement séparés, créez des dossiers appropriés sur le système hôte. Nous utilisons la structure de dossiers suivante (mais vous pouvez organiser les dossiers autrement) :

```bash
mkdir -p ~/jellyfin/config
mkdir -p ~/jellyfin/cache
mkdir -p ~/medias/films
mkdir -p ~/medias/series
mkdir -p ~/medias/musique
mkdir -p ~/medias/photos
```

`config` contiendra ultérieurement la configuration du serveur, les utilisateurs et la base de données. `cache` est destiné aux données temporaires. Les véritables fichiers multimédias se trouvent dans les dossiers de bibliothèque séparés.

### Étape 5 : déterminer l’UID et le GID de l’utilisateur

Jellyfin peut s’exécuter dans le conteneur avec l’ID utilisateur et l’ID de groupe de votre utilisateur Linux. Cela facilite la gestion des droits sur les fichiers. Commencez donc par déterminer ces deux valeurs avec :

```bash
id
```

Vous aurez bientôt besoin des nombres affichés dans le fichier Compose, il est donc recommandé de les noter.

### Étape 6 : créer le fichier Docker Compose pour Jellyfin

Passez dans le répertoire de travail et créez un fichier nommé `docker-compose.yml`. Nous utilisons l’éditeur de texte nano pour la création, mais vous pouvez créer le fichier de n’importe quelle autre manière.

```bash
mkdir -p ~/jellyfin
cd ~/jellyfin
nano docker-compose.yml
```

Insérez le contenu suivant dans le fichier que vous venez de créer :

```yaml
services:
    jellyfin:
        image: jellyfin/jellyfin
        container_name: jellyfin
        user: "1000:1000"
        ports:
            - "8096:8096/tcp"
            - "7359:7359/udp"
        volumes:
            - ./config:/config
            - ./cache:/cache
            - type: bind
                source: /home/VOTRE_UTILISATEUR/medias/films
                target: /medias/films
                read_only: true
            - type: bind
                source: /home/VOTRE_UTILISATEUR/medias/series
                target: /medias/series
                read_only: true
            - type: bind
                source: /home/VOTRE_UTILISATEUR/medias/musique
                target: /medias/musique
                read_only: true
            - type: bind
                source: /home/VOTRE_UTILISATEUR/medias/photos
                target: /medias/photos
                read_only: true
        environment:
            - JELLYFIN_PublishedServerUrl=http://VOTRE-IP-SERVEUR:8096
        restart: unless-stopped
```

Remplacez ensuite dans le fichier :

- la valeur `1000:1000` par votre véritable UID:GID, que vous avez notée à l’étape précédente
- `VOTRE_UTILISATEUR` par votre nom d’utilisateur Linux
- `VOTRE-IP-SERVEUR` par l’[adresse IP](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-quune-adresse-ip/) de votre serveur

Conseil Les dossiers de médias sont ici montés avec `read_only: true`. Cela signifie que Jellyfin peut lire les fichiers, mais pas les modifier. Pour un serveur Jellyfin personnel, cette configuration est plus pertinente et plus sûre.

### Étape 7 : démarrer le conteneur Jellyfin

Vous pouvez maintenant démarrer le conteneur créé avec Docker Compose en arrière-plan :

```bash
sudo docker compose up -d
```

Vérifiez ensuite si le conteneur est en cours d’exécution :

```bash
sudo docker compose ps
```

[![Image: Affichage après Docker compose](https://www.ionos.fr/digitalguide/fileadmin/_processed_/f/4/csm_jellyfin-docker-compose_555ea97a3a.webp "Affichage après Docker compose")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/jellyfin-docker-compose.jpg) La sortie du terminal vous confirme que l’installation de Jellyfin a réussi et que le conteneur avec Jellyfin est en cours d’exécution. ### Étape 8 : ouvrir Jellyfin dans le navigateur

Saisissez maintenant dans votre navigateur l’adresse de votre serveur avec le port Jellyfin par défaut :

```none
http://VOTRE-IP-SERVEUR:8096
```

L’assistant de configuration démarre alors dans le navigateur.

Note Si vous louez un serveur IONOS, vous devez d’abord configurer le [pare-feu](https://www.ionos.fr/digitalguide/serveur/securite/quest-ce-quun-pare-feu/) dans le Cloud Panel pour autoriser les connexions [TCP](https://www.ionos.fr/digitalguide/serveur/know-how/presentation-de-tcp/) via le port 8096.

### Étape 9 : première configuration dans l’assistant Jellyfin

Dans le navigateur, Jellyfin vous guide à travers la **configuration de base**. Définissez d’abord la langue, puis créez un compte administrateur avec un mot de passe sécurisé. Configurez ensuite vos bibliothèques. Sélectionnez par exemple « Films », « Séries », « Musique » ou « Photos », puis indiquez pour chacune les répertoires montés dans le conteneur, dans notre exemple `/medias/films` ou `/medias/series`. Jellyfin télécharge ensuite les métadonnées, les jaquettes et d’autres informations, à condition que votre serveur dispose d’un accès Internet.

[![Image: Capture d’écran de Jellyfin dans le navigateur](https://www.ionos.fr/digitalguide/fileadmin/_processed_/5/6/csm_jellyfin-server-setup_dd8c16e054.webp "Capture d’écran de Jellyfin dans le navigateur")](https://www.ionos.fr/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/jellyfin-server-setup.jpg) Lorsque vous ouvrez Jellyfin dans le navigateur, l’assistant vous guide à travers la configuration. ### Étape 10 : structurer proprement vos médias

Pour que Jellyfin reconnaisse correctement vos fichiers, vos médias doivent être bien nommés et bien rangés. Pour les films, un répertoire dédié par titre est utile ; pour les séries, une subdivision par saison est recommandée. La musique bénéficie surtout de métadonnées soigneusement renseignées. Plus votre arborescence est claire, moins vous aurez ensuite de corrections manuelles à effectuer pour les métadonnées et l’attribution des contenus. Ce n’est pas une contrainte technique stricte, mais cela fait une vraie différence en pratique.

Veuillez respecter les **consignes de sécurité suivantes pour votre serveur Jellyfin** :

- **Utiliser HTTPS :** si vous rendez Jellyfin accessible via Internet, vous devez absolument sécuriser l’accès avec HTTPS. Le plus simple est de passer par un reverse proxy avec un certificat TLS gratuit, par exemple via Let’s Encrypt ou l’ACME automatique de Caddy.
- **Éviter l’accès direct depuis Internet :** si possible, n’ouvrez pas directement le port Jellyfin sur votre routeur. Il est préférable de passer par un reverse proxy ou un [VPN](https://www.ionos.fr/digitalguide/serveur/know-how/quest-ce-quun-vpn-virtual-private-network/).
- **Utiliser des mots de passe robustes :** définissez un [mot de passe sécurisé](https://www.ionos.fr/digitalguide/serveur/securite/protegez-vos-donnees-sensibles-avec-un-mot-de-passe-securise/) pour le compte administrateur et créez des comptes utilisateurs séparés pour les autres personnes.
- **Mettre régulièrement le système à jour :** gardez votre système Ubuntu, Docker et l’image Jellyfin à jour grâce à des mises à jour régulières.
- **Monter les répertoires médias en lecture seule :** si vous exécutez Jellyfin dans Docker, il est recommandé de monter les dossiers médias en lecture seule (`read_only`) afin d’éviter toute modification accidentelle de vos fichiers.

## Comment connecter Jellyfin à un domaine ?

Pour accéder à Jellyfin via un domaine comme `jellyfin.votredomaine.fr`, vous avez besoin de trois éléments :

- Un [domaine](https://www.ionos.fr/digitalguide/domaines/conseils-sur-le-domaine/quest-ce-quun-domaine/) ou un sous-domaine
- Une [entrée DNS](https://www.ionos.fr/digitalguide/serveur/know-how/domain-name-system/) qui pointe vers l’adresse IP publique de votre serveur
- Un reverse proxy avec HTTPS, Caddy étant une option simple grâce à sa gestion automatique des certificats

### Étape 1 : créer l’entrée DNS pour le sous-domaine

Créez un [enregistrement A](https://www.ionos.fr/digitalguide/hebergement/aspects-techniques/a-record/) chez votre fournisseur de domaine, par exemple :

```none
jellyfin.votredomaine.fr -> VOTRE-IP-PUBLIQUE
```

Si vous utilisez IPv6, définissez également un enregistrement AAAA. Pour que le HTTPS automatique avec Caddy fonctionne, l’entrée DNS doit déjà pointer correctement vers votre serveur.

Note Pour que votre instance Jellyfin soit ensuite accessible en HTTPS, les ports 80 (HTTP) et 443 (HTTPS) doivent être ouverts sur le serveur ou dans le pare-feu. Le reverse proxy a besoin de ces ports pour recevoir les requêtes Web et obtenir les certificats TLS.

### Étape 2 : installer Caddy

Caddy est un choix courant pour Jellyfin en raison de sa configuration HTTPS simple et de sa gestion automatique des certificats. Installez Caddy sur Ubuntu via le dépôt officiel, en utilisant les commandes suivantes dans le terminal :

```bash
sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo chmod o+r /usr/share/keyrings/caddy-stable-archive-keyring.gpg
sudo chmod o+r /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy -y
```

Après l’installation, Caddy démarre automatiquement en tant que service système.

### Étape 3 : configurer Caddy

Modifiez ensuite la configuration de Caddy. Nous utilisons de nouveau nano, mais tout autre éditeur de texte fonctionne :

```bash
sudo nano /etc/caddy/Caddyfile
```

Insérez le contenu suivant :

```none
jellyfin.votredomaine.fr {
    reverse_proxy 127.0.0.1:8096
}
```

Enregistrez le fichier et vérifiez la configuration :

```bash
sudo caddy validate --config /etc/caddy/Caddyfile
```

Si tout est correct, rechargez Caddy avec la commande suivante :

```bash
sudo systemctl reload caddy
```

### Étape 4 : lier Jellyfin localement à Caddy uniquement

Si le fonctionnement du domaine est correct, vous devez adapter le fichier Compose afin que Jellyfin **n’écoute plus publiquement sur le port 8096**. Pour cela, rouvrez `~/jellyfin/docker-compose.yml` et remplacez l’entrée de port :

```yaml
ports:
    - "127.0.0.1:8096:8096/tcp"
    - "7359:7359/udp"
```

Ensuite, redémarrez le conteneur :

```bash
sudo docker compose up -d
```

L’interface Web est maintenant uniquement liée à l’environnement local, tandis que Caddy prend en charge la connexion publique sécurisée. Enfin, vous devez ajouter le proxy comme **Known Proxy** dans les paramètres réseau de Jellyfin. Jellyfin pourra ainsi gérer correctement les en-têtes définis par le proxy. Vous trouverez ce réglage dans l’interface Web sous « Dashboard &gt; Networking &gt; Known Proxies ».


This is a markdown version of: [https://www.ionos.fr/digitalguide/serveur/configuration/serveur-jellyfin/](https://www.ionos.fr/digitalguide/serveur/configuration/serveur-jellyfin/) for AI/LLM consumption.