jellyfin/jellyfin.org
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin.org.git synced 2025-03-01 18:18:13 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove outdated docs

Browse Source
This commit is contained in:
Bill Thornton 2022-08-18 01:15:50 -04:00
parent d784086d12
commit 7cb5d133a2
54 changed files with 0 additions and 5561 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
docs/building.md
View File

@ -1,114 +0,0 @@
---
id: admin-building
title: Building from source
sidebar_position: 4
---
As an alternative to using [binary packages](xref:admin-installing), you can build Jellyfin from source.
Jellyfin supports several methods of building for different platforms and instructions for all supported platforms are below.
All package builds begin with these two steps:
1. Clone the repository.
```sh
git clone https://github.com/jellyfin/jellyfin.git
cd jellyfin
```
2. Initialize the submodules.
```sh
git submodule update --init
```
## Container image
1. Build the container image using Docker or Podman.
```sh
docker build -t $USERNAME/jellyfin .
```
or
```sh
podman build -t $USERNAME/jellyfin .
```
2. Run Jellyfin in a new container using Docker or Podman from the built container image.
```sh
docker run -d -p 8096:8096 $USERNAME/jellyfin
```
or
```sh
podman run -d -p 8096:8096 $USERNAME/jellyfin
```
## Linux or MacOS
3. Use the included `build` script to perform builds.
```sh
./build --help
./build --list-platforms
./build <platform> all
```
4. The resulting archives can be found at `../bin/<platform>`.
> [!NOTE]
> This will very likely be split out into a separate repository at some point in the future.
## Windows
3. Install the dotnet core SDK 3.1 from [Microsoft's Website](https://dotnet.microsoft.com/download/dotnet-core/3.1) and [install Git for Windows](https://gitforwindows.org/). You must be on Powershell 3 or higher.
4. From Powershell set the execution policy to unrestricted.
```powershell
set-executionpolicy unrestricted
```
5. If you are building a version of Jellyfin newer than 10.6.4, you will need to download the build script from a separate repository.
```powershell
git clone https://github.com/jellyfin/jellyfin-server-windows.git windows
```
6. Run the Jellyfin build script.
```powershell
windows\build-jellyfin.ps1 -verbose
```
* The `-WindowsVersion` and `-Architecture` flags can optimize the build for your current environment; the default is generic Windows x64.
* The `-InstallLocation` flag lets you select where the compiled binaries go; the default is `$Env:AppData\Jellyfin-Server\`.
* The `-InstallFFMPEG` flag will automatically pull the stable `ffmpeg` binaries appropriate to your architecture (x86/x64 only for now) from [Zeranoe](https://ffmpeg.zeranoe.com/builds/) and place them in your Jellyfin directory.
* The `-InstallNSSM` flag will automatically pull the stable `nssm` binary appropriate to your architecture (x86/x64 only for now) from [NSSM's Website](https://nssm.cc/) and place it in your Jellyfin directory.
7. (Optional) Use [NSSM](https://nssm.cc) to configure Jellyfin to run as a service.
8. Jellyfin is now available in the default directory, or whichever directory you chose.
* Start it from PowerShell.
```powershell
&"$env:APPDATA\Jellyfin-Server\jellyfin.exe"
```
* Start it from CMD.
```cmd
%APPDATA%\Jellyfin-Server\jellyfin.exe
```
> [!NOTE]
> This will very likely be split out into a separate repository at some point in the future.

3
docs/clients/_category_.json
View File

@ -1,3 +0,0 @@
{
"label": "Client configuration"
}

166
docs/clients/kodi.md
View File

@ -1,166 +0,0 @@
---
id: kodi
title: Kodi
---
# Kodi
## Add-on Repository
### Install Add-on Repository
The most convenient install method of our Jellyfin add-ons is to use the official Kodi Jellyfin Repository. Using this repository allows for easy install of our add-ons, as well as automatically keeping the add-ons up to date with the latest version. Any other Jellyfin related add-ons that may be built in the future will also be available here.
The installation method for the repository varies depending on what kind of device you're using, outlined below.
#### General Use Devices (PCs and Tablets)
1. Download the repository installer found [here](https://kodi.jellyfin.org/repository.jellyfin.kodi.zip).
* It will be saved as `repository.jellyfin.kodi.zip`
2. Install the Jellyfin repository.
* Open Kodi, go to the settings menu, and navigate to "Add-on Browser"
* Select "Install from Zip File"
* If prompted, enter settings and enable "Unknown Sources", then go back to the Add-on Browser
* Select the newly downloaded file and it will be installed
#### "Embedded" Devices (Android TV, Firestick, and other TV Boxes)
1. Open Kodi, go to the settings menu, and navigate to "File manager"
* Select "Add source"
* In the text box, enter `https://kodi.jellyfin.org`
* Enter a name for the data source, such as "Jellyfin Repo" and select Ok
2. From the settings menu, navigate to "Add-on Browser"
* Select "Install from Zip File"
* If prompted, enter settings and enable "Unknown Sources", then go back to the Add-on Browser
* Select the data source you just added
* Install `repository.jellyfin.kodi.zip`
## Jellyfin for Kodi
> [!TIP]
> It's highly recommended to install the `Kodi Sync Queue` plugin into the Jellyfin server as well.
> This will keep your media libraries up to date without waiting for a periodic re-sync from Kodi.
> [!CAUTION]
> Remote Kodi databases, like MySQL, are not supported. A local SQLite database is required (this is the default).
### Jellyfin for Kodi Overview
This addon syncs metadata from selected Jellyfin libraries into the local Kodi database. This has the effect of making interacting with it feel very much like vanilla Kodi with local media. This means that our Jellyfin content will be displayed on the home screen under the proper media headings by default, it has virtually no delay while interacting with the library, etc. However, it also assumes that it's the only media source and in largely incompatible with other media sources that interact with Kodi's database.
Media in Kodi's database is automatically kept in sync with the server in one of several ways:
* Startup sync - Each time Kodi starts, it will reach out to the Kodi Sync Queue plugin in the server and request all updated media since it's last checkin time (when Kodi was last shut down)
* Live sync - This happens while Kodi is running. When the server updates an item, it will send a notification to Kodi over a websocket connection that it has new media that needs to be updated.
### Install Jellyfin for Kodi Add-on
1. Install Jellyfin for Kodi.
* From within Kodi, navigate to "Add-on Browser"
* Select "Install from Repository"
* Choose "Kodi Jellyfin Addons", followed by "Video Add-ons"
* Select the Jellyfin add-on and choose install
2. Within a few seconds you should be prompted for your server details.
* If a Jellyfin server is detected on your local network, it will displayed in a dialog
* If a Jellyfin server is not detected on your local network, select "Manually Add Server". Enter your server info into the text field.
* Enter the server name or IP address and the port number (default value is 8096)
* Host: `192.168.1.10:8096`
* If using SSL and a reverse proxy, enter the full URL in the "Host" field
* Host: `https://jellyfin.example.com`
* Note that if you have a baseurl set, you should append that value to the end of the host field.
* Host: `192.168.0.10:8096/jellyfin`
* Select user account and input password, or select "Manual Login" and fill in your user infomation
3. Once you're succesfully authenticated with the server, you'll be asked about which mode you'd like to use, Add-on vs Native, which are outlined below.
#### Add-on Mode
Add-on mode uses the Jellyfin server to translate media files from the filesystem to Kodi. This is the default setting for the add-on, and is sufficient for most use cases. It will work both on the local network and over the Internet through a reverse proxy or VPN connection. Providing network speed is sufficient, Kodi will direct play nearly all files and put little overhead on the Jellyfin server. Exceptions to this rule are files with 7.1 audio tracks and some 4k content, which will be transcoded by the server.
To use Add-on mode, simply choose "Add-on" at the dialog and proceed to [Library Syncing](xref:clients-kodi#library-syncing)
#### Native Mode
Native mode accesses your media files directly from the filesystem, bypassing the Jellyfin server during playback. Native mode needs more setup and configuration, but it can, on rare occasions, lead to better performance where network bandwidth is a limitation. It requires your media to be available to the device Kodi is running on over either NFS or Samba, and therefore should only be used on a LAN or over a VPN connection.
To use Native mode, first set up your libraries in Jellyfin with a remote path.
1. In the Jellyfin server, navigate to the Libraries section of the admin dashboard.
* Select an existing library (or create a new one)
* Select the media folder
* Enter the path to your network share in the "Shared network folder" textbox
* Possible formats:
* NFS
* `nfs://192.168.0.10:/path/to/media`
* Samba
* Guest User - `\\192.168.0.10\share_name`
* Custom User (Not Recommended) - `\\user:password@192.168.0.10\share_name`
* It's more secure to use the generic Guest mapping here and specify credentials from within Kodi
* Mounted share
* If you have mounted your network share, you can reference the local mount point. This can be more performant but generally means it only works for one type of operating system, given the difference between the file systems
* `/mnt/media` (Linux)
* `Z:\media` (Windows)
* `/Volumes/media` (Mac OS)
2. Configure libraries in Kodi
* Skip the initial library selection. We need to add file shares to Kodi first
* Within Kodi, navigate to the settings menu and select "File manager"
* Select "Add source"
* Select "Browse" and "Add network location"
* Create either a NFS or SMB location from the selection box and fill in the necessary information about your network share
* If you are using a mounted share, browse to the mount point on your file system rather than the network share
* Select your newly created location and choose "Ok"
* Give your media source a name and choose "Ok"
* Go to Add-ons -> Jellyfin -> Manage Libraries -> Add Libraries
3. Proceed to [Library Syncing](xref:clients-kodi#library-syncing)
#### Library Syncing
This screen allows you to choose which libraries to sync to your Kodi install. This process will copy metadata for your media into the local Kodi database, allowing you to browse through your media libraries as if they were native to your device.
Either choose "All" or select individual libraries you'd like synced, and select OK. Syncing the metadata will start automatically. The duration of this process varies greatly depending on the size of your library, the power of your local device, and the connection speed to the server.
You can still access any libraries that haven't been synced by going through the Jellyfin add-on menu. These unsynced libraries will be labeled as "dynamic."
If an error occurs during syncing, enable debug logging in the Jellyfin add-on in Kodi and if in a Unix-like OS, set the **log level** of Samba to 2 to see if there are issues authenticating.
### Multiple User Accounts
The Jellyfin for Kodi addon doesn't natively handle multiple user accounts. Fortunately, Kodi has a built in method of handling this called profiles. Information about this can be found on the Profiles page of the [Kodi Wiki](https://kodi.wiki/view/Profiles). Once profiles have been created, you must install the Jellyfin add-on and go through the installation steps above for each user profile. When you switch Kodi profiles, you will also switch Jellyfin users. You can tell Kodi to bring you to a profile login screen during startup by going to the Profiles section inside of the Settings page and checking the box for "Show login screen on startup."
> [!NOTE]
> Kodi's default skin does not display all unicode characters. To display unicode characters the skin's font must be changed.
### Multiple Clients
When using multiple Kodi clients do not copy Kodi's database (i.e. `myvideosXYZ.db`, `jellyfin.db`) files from one client to the other to try and reduce initial syncing time. This will partially work, but it will cause conflicts between clients and the sync process from the server won't work properly.
## JellyCon
### JellyCon Overview
JellyCon behaves more like a standard Kodi streaming addon. Media is accessed primarily by going through the Add-ons -> JellyCon menu, however depending on what skin is being used custom shortcuts and widgets can be added to the home menu. It also allows easier switching between multiple Jellyfin servers or users since it doesn't have to rely on syncing all the metadata down. By not having metadata synced, it has to request info from the server which can take a bit more time when you're browsing, but you don't have to wait for the database to sync or keep it up to date. It's also compatible with other media sources and can be used with other add-ons without issue.
### Install JellyCon Add-on
1. Instally JellyCon Add-on
* From within Kodi, navigate to "Add-on Browser"
* Select "Install from Repository"
* Choose "Kodi Jellyfin Addons", followed by "Video Add-ons"
* Select the JellyCon add-on and choose install
2. Within a few seconds you should be prompted for your server details.
* If a Jellyfin server is detected on your local network, it will displayed in a dialog. Otherwise, you will be prompted for a URL
* Select a user from the list, or Manual Login to type in a username/password
### Configuring Home
Many Kodi skins allow for customizing of the home menu with custom nodes and widgets. However, all of these use slightly different layouts and terminology. Rather than a step by step guide, this section serves as an barebones introduction to customizing a skin.
#### Examples
If you would like a link on the home screen to open a library in your Jellyfin server called "Kid's Movies", you would point the menu item to the path: `Add-On -> Video Add-On -> JellyCon -> Jellyfin Libraries -> Kid's Movies -> Create menu item to here`.
Beyond just modifying where the home menu headers go, many skins also allow you to use widgets. Widgets help populate the home screen with data, often the posters of media in the selected image. If you would like to display the most recent movies across all of your Jellyfin libraries on the home screen, the path would be: `Add-On -> Video Add-On -> JellyCon -> Global Lists -> Movies -> Movies - Recently Added (20) -> Use as widget`
Another common use case of widgets would be to display the next available episodes of shows that you may be watching. As above, this can be done both with individual libraries or with all libraries combined:
* `Add-On -> Video Add-On -> JellyCon -> Jellyfin Libraries -> Anime -> Anime - Next Up (20) -> Use as widget`
* `Add-On -> Video Add-On -> JellyCon -> Global Lists -> TV Shows -> TV Shows - Next Up (20) -> Use as widget`

117
docs/clients/mopidy.md
View File

@ -1,117 +0,0 @@
---
id: mopidy
title: Mopidy
---
# Installing Mopidy Extension
The Mopidy Jellyfin extension is available to install from [PyPi](https://pypi.org/project/Mopidy-Jellyfin) using pip.
## General
For general use computers, such as workstations or laptops, it's recommended to install Mopidy extensions in user mode. Installing python packages from pip using sudo or root permissions can lead to conflicts with your package manager in the future.
1. Install Mopidy using your method of choice using the [official documentation](https://docs.mopidy.com/en/latest/installation/)
2. Install the Jellyfin extension for Mopidy:
```sh
pip3 install --user mopidy-jellyfin
```
3. (Optional) Install other mopidy related packages:
```sh
pip3 install --user mopidy-mpd mopidy-musicbox-webclient
```
4. Configure your `mopidy.conf` located at `$HOME/.config/mopidy/mopidy.conf`
See [Config File](xref:clients-mopidy#config-file)
5. There may be a need to install extra `gstreamer` codecs if they're not already on your system, but these are highly variable and depend on your hardware and distro
6. Start the program by running `mopidy` from a terminal
7. See [Usage](xref:clients-mopidy#usage)
## Raspberry Pi (Remote Controlled Speakers)
Utilizing a Raspberry Pi (or other small form factor computer) it's possible to use Mopidy to build a set of standalone smart speakers connected to your Jellyfin server.
1. Grab the latest [raspbian image](https://www.raspberrypi.org/downloads/raspbian/). Unless you have a need for a GUI, the 'Lite' image is plenty for this project.
2. Install the image to the SD card (See the [official documentation](https://www.raspberrypi.org/documentation/installation/installing-images/README.md))
3. Install Mopidy from their [apt repo](https://docs.mopidy.com/en/latest/installation/debian/#install-from-apt-mopidy-com) to ensure we get the latest version
4. Install required OS packages:
```sh
sudo apt install mopidy mopidy-mpd gstreamer1.0-plugins-bad python3-pip
```
5. Install the Jellyfin extension and any other Mopidy related packages you may want:
```sh
sudo pip3 install mopidy-jellyfin mopidy-musicbox-webclient
```
6. Configure your `mopidy.conf` located at `/etc/mopidy/mopidy.conf`:
See [Config File](xref:clients-mopidy#config-file)
7. Enable and start the mopidy service:
```sh
sudo systemctl enable --now mopidy
```
8. See [Usage](xref:clients-mopidy#usage)
## Config File
The config file for Mopidy is divided into sections in an INI format. An example for Jellyfin is shown here.
```ini
[jellyfin]
hostname = Jellyfin server hostname
username = username
password = password
libraries = Library1, Library2 (Optional: will default to "Music" if left undefined)
albumartistsort = False (Optional: will default to True if left undefined)
album_format = {ProductionYear} - {Name} (Optional: will default to "{Name}" if left undefined)
```
* `libraries` determines what is populated into Mopidy's internal library (view by Artists/Album/etc). Using the file browser will show all music or book libraries in the Jellyfin server
* `albumartistsort` changes whether the media library populates based on "Artist" or "Album Artist" metadata
* `album_format` can be used to change the display format of music albums when using the file browser view. Currently the only really usable fields are ProductionYear and Name
Other options that may be useful to include:
```ini
[mpd]
enabled = true
# Useful if you want to control this instance from a remote MPD client
hostname = 0.0.0.0
port = 6600
# This will help avoid timeout errors for artists or folders with large amounts of files
connection_timeout = 300
# Used in the event you want to control this system from a web browser
[http]
hostname = 0.0.0.0
port = 6680
```
Be aware that Mopidy provides no security on open ports, so if you'll be running this in a public place you'll likely want to change `0.0.0.0` to `127.0.0.1` to prevent somebody else from hijacking your listening session.
## Usage
Once Mopidy is running, you can connect and control it with your client of choice. MPD clients will connect using port 6600 by default. Tested MPD clients include [ncmpcpp](https://github.com/arybczak/ncmpcpp) and [M.A.L.P](https://play.google.com/store/apps/details?id=org.gateshipone.malp). Web clients can be reached at `http://localhost:6680`, or `http://$IP_ADDRESS:6680` if this is a remote system.
## Upgrading
When a new version of Mopidy Jellyfin is released, you can upgrade via pip using the `--upgrade` flag.
```sh
pip3 install --user --upgrade mopidy-jellyfin
```

52
docs/clients/web-config.md
View File

@ -1,52 +0,0 @@
---
id: clients-web-config
title: Jellyfin Web Configuration
---
# Jellyfin Web Configuration
## Editing
The Jellyfin Web default interface can be configured using the `config.json` file in the webroot. Where this is and how to edit it depends on the installation method.
### Debian/Ubuntu/Fedora/CentOS Packages
The configuration can be found at `/usr/share/jellyfin/web/config.json`. This file is registered as a configuration file by the Debian packages, and any changes to the defaults will be handled by `apt` on upgrade.
### Docker
Overriding the default `config.json` can be done with an additional volume parameter to your `docker run` command, e.g.
```sh
--volume /path/to/config/web-config.json:/jellyfin/jellyfin-web/config.json
```
We would recommend obtaining the [latest copy of the file](https://github.com/jellyfin/jellyfin-web/blob/master/src/config.json) to pre-populate your configuration directory before starting Jellyfin for the first time; unlike most other components of this directory, it will not be created automatically on first run.
## Privacy-focused changes
Our default settings for the Jellyfin Web `config.json` file include some features that privacy-focused or completely-offline users may with to disable. Each option is detailed below.
### Google Chromecast
By default, Jellyfin Web includes Chromecast-from-browser support. This requires downloading files from Google servers to support this functionality.
To disable it, edit `config.json` and remove the line:
```json
"plugins/chromecastPlayer/plugin"
```
in the `plugins` section. Be sure to remove the last comma from the line above if this is the last line in the list.
### YouTube Trailers
By default, Jellyfin Web includes functionality to auto-load movie trailers from YouTube. This functionality is disabled within Jellyfin by default, but the resources are included in the Web config to make enabling the feature easy.
To disable it, edit `config.json` and remove the line:
```json
"plugins/youtubePlayer/plugin"
```
in the `plugins` section.

3
docs/configuration/_category_.json
View File

@ -1,3 +0,0 @@
{
"label": "Server configuration"
}

97
docs/configuration/general-configuration.md
View File

@ -1,97 +0,0 @@
---
id: general-configuration
title: General information
---
There are several entry points available for administrators to manage the configuration of their server. This section aims to outline all those configuration methods, explain what options are available, and what each option does.
> [!NOTE]
> The configuration options here are distinct from the [runtime settings](xref:server-settings) available from the Administrator Dashboard in the web client. The configuration options here are generally meant to be static and set before starting the server.
## Command Line Options
Documentation for the available command line options can be obtained by adding the `--help` flag when running the Jellyfin executable.
## Server Paths
The file paths used by the server are determined according the rules outline below. In general, the [XDG specification](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html) is followed by default for non-Windows systems.
### Data Directory
This is the directory that will hold all Jellyfin data, and is also used as a default base directory for some other paths below. It is set from the following sources in order of decreasing precedence.
1. Command line option `--datadir`, if specified
2. Environment variable `JELLYFIN_DATA_DIR`, if specified
3. `<%APPDATA%>/jellyfin`, if running on Windows
4. `$XDG_DATA_HOME/jellyfin`, if `$XDG_DATA_HOME` exists
5. `$HOME/.local/share/jellyfin`
### Configuration Directory
This is the directory containing the server configuration files. It is set from the following sources in order of decreasing precedence.
1. Command line option `--configdir`, if specified
2. Environment variable `JELLYFIN_CONFIG_DIR`, if specified
3. `<Data Directory>/config`, if it exists or if running on Windows
4. `$XDG_CONFIG_HOME/jellyfin` if `$XDG_CONFIG_HOME` exists
5. `$HOME/.config/jellyfin`
### Cache Directory
This is the directory containing the server cache. It is set from the following sources in order of decreasing precedence.
1. Command line option `--cachedir`, if specified
2. Environment variable `$JELLYFIN_CACHE_DIR`, if specified
3. `<Data Directory>/cache`, if Windows
4. `$XDG_CACHE_HOME/jellyfin` if `$XDG_CACHE_HOME` exists
5. `$HOME/.cache/jellyfin`
### Web Directory
This is the directory containing the built files from a [web client](https://github.com/jellyfin/jellyfin-web) release. It is set from the following sources in order of decreasing precedence.
1. Command line option `--webdir`, if specified
2. Environment variable `$JELLYFIN_WEB_DIR`, if specified
3. `<Binary Directory>/jellyfin-web`, where `<Binary Directory>` is the directory containing the Jellyfin executable
> [!NOTE]
> This setting is only used when the server is configured to host the web client. See the `hostwebclient` option in the [Main Configuration Options](#main-configuration-options) section below for additional details.
### Log Directory
This is the directory where the Jellyfin logs will be stored. It is set from the following sources in order of decreasing precedence.
1. Command line option `--logdir`, if specified
2. Environment variable `$JELLYFIN_LOG_DIR`, if specified
3. `<Data Directory>/log`
## Main Configuration
The main server configuration is built upon the ASP .NET [configuration framework](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-3.1), which provides a tiered approach to loading configuration. The base directory to locate the configuration files is set using the [configuration directory](#configuration-directory) setting. The configuration sources are as follows, with later sources having higher priority and overwriting the values in earlier sources.
1. **Hard-coded default values**: These defaults are specified in the Jellyfin [source code](https://github.com/jellyfin/jellyfin/blob/master/Emby.Server.Implementations/ConfigurationOptions.cs) and cannot be changed.
2. **Default logging configuration file** (`logging.default.json`): This file should not be modified manually by users. It is reserved by the server to be overwritten with new settings on each new release.
3. **System-specific logging configuration file** (`logging.json`): This is the file you should change if you want to have a custom logging setup. Jellyfin uses the [Serilog](https://serilog.net/) logging framework, and you can read about the configuration options available in their [documentation](https://github.com/serilog/serilog-settings-configuration).
> [!NOTE]
> This file can be changed at runtime, which will automatically reload the configuration and apply the changes immediately.
4. **Environment variables**: The [documentation](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-3.1#environment-variables) provided by Microsoft explains how to set these configuration options via environment variables. Jellyfin uses its own custom `JELLYFIN_` prefix for these variables. For example, to set a value for the `HttpListenerHost:DefaultRedirectPath` setting, you would set a value for the `JELLYFIN_HttpListenerHost__DefaultRedirectPath` environment variable.
5. **Command line options**: Certain command line options are loaded into the configuration system and have the highest priority. The following command line options are mapped to associated configuration options.
- `--nowebcontent` sets the `hostwebclient` configuration setting to false
- `--plugin-manifest-url` sets a value for the `InstallationManager:PluginManifestUrl` configuration setting
### Main Configuration Options
This section lists all the configuration options available and explains their function.
|Key|Default Value|Description|
|---|-------------|-----------|
|`hostwebclient`|`True`|Set to `True` if the server should host the web client.|
|`HttpListenerHost:DefaultRedirectPath`|`"web/index.html"` if `hostwebclient` is true; `"swagger/index.html"` if `hostwebclient` is false|The default redirect path to use for requests where the URL base prefix is invalid or missing|
|`InstallationManager:PluginManifestUrl`|`"https://repo.jellyfin.org/releases/plugin/manifest.json"`|The URL for the plugin repository JSON manifest.|
|`FFmpeg:probesize`|`"1G"`|Value to set for the FFmpeg `probesize` format option. See the FFmpg [documentation](https://ffmpeg.org/ffmpeg-formats.html#Format-Options) for more details.|
|`FFmpeg:analyzeduration`|`"200M"`|The value to set for the FFmpeg `analyzeduration` format option. See the FFmpg [documentation](https://ffmpeg.org/ffmpeg-formats.html#Format-Options) for more details.|
|`playlists:allowDuplicates`|`True`|Whether playlists should allow duplicate items or automatically filter out duplicates.|
|`PublishedServerUrl`|Server Url based on primary IP address|The Server URL to publish in udp Auto Discovery response.|

469
docs/configuration/hardware-acceleration.md
View File

@ -1,469 +0,0 @@
---
id: admin-hardware-acceleration
title: Hardware Acceleration
---
# Hardware Acceleration
Jellyfin supports [hardware acceleration](https://trac.ffmpeg.org/wiki/HWAccelIntro) (HWA) of video encoding/decoding using FFMpeg. FFMpeg and Jellyfin can support multiple hardware acceleration implementations such as Intel Quicksync (QSV), AMD AMF, nVidia NVENC/NVDEC, OpenMax OMX and MediaCodec through Video Acceleration API's.
[VAAPI](https://en.wikipedia.org/wiki/Video_Acceleration_API) is a Video Acceleration API that uses [libva](https://github.com/intel/libva/blob/master/README.md) to interface with local drivers to provide HWA. [QSV](https://trac.ffmpeg.org/wiki/Hardware/QuickSync) uses a modified (forked) version of VAAPI and interfaces it with [libmfx](https://github.com/intel/media-driver/blob/master/README.md) and their proprietary drivers [(list of supported processors for QSV)](https://ark.intel.com/content/www/us/en/ark.html#@Processors).
OS | Recommended HW Acceleration
------- | -------------
Linux | QSV, NVENC, AMF, VAAPI
Windows | QSV, NVENC, AMF
MacOS | VideoToolbox
Android | MediaCodec, OMX
RPi | OMX
[Graphics Cards comparison using HWA](https://www.elpamsoft.com/?p=Plex-Hardware-Transcoding)
## NVIDIA NVENC
[NVIDIA using ffmpeg official list](https://developer.nvidia.com/ffmpeg). Not every card has been tested. These [drivers](https://github.com/keylase/nvidia-patch) are recommended for Linux and Windows. Here is the official list of [NVIDIA Graphics Cards](https://developer.nvidia.com/video-encode-decode-gpu-support-matrix) for supported codecs. Example of Ubuntu working with [NVENC](https://www.reddit.com/r/jellyfin/comments/amuyba/nvenc_nvdec_working_in_jellyfin_on_ubuntu_server/). H264 10-bit is [not supported](https://devtalk.nvidia.com/default/topic/1039388/video-codec-and-optical-flow-sdk/is-there-nvidia-encoder-decoder-which-supports-hdr-10-bpp-for-avc-h-264-/) by NVIDIA acceleration. **The minimum required driver version is: Linux: 418.30, Windows: 450.51.**
## VAAPI
List of supported codecs for [VAAPI](https://wiki.archlinux.org/index.php/Hardware_video_acceleration#Comparison_tables). Both Intel iGPU and AMD GPU can use VAAPI.
> [!NOTE]
> AMD GPU requires open source driver Mesa 20.1 or higher to support hardware decoding HEVC.
> [!NOTE]
> As of 10.7.1, the Docker image uses Debian 10 and thus Mesa 18.3.6. To upgrade it, you'll need to make your own image based on a more recent distribution.
## AMD AMF
AMF is now available on Windows and Linux, but since AMD has not implemented the HW decoder and scaler in ffmpeg, the decoding speed may not be as expected. The closed source driver `amdgpu-pro` is required when using AMF on Linux.
> [!NOTE]
> Most Zen CPUs do not come with integrated graphics. You will need a dedicated GPU (dGPU) or a Zen CPU with integrated graphics for hardware acceleration. If your Zen CPU is suffixed with a "G" or "GE" in model name, you have integrated graphics.
## Intel QuickSync
Intel QSV Benchmarks on [Linux](https://www.intel.com/content/www/us/en/architecture-and-technology/quick-sync-video/quick-sync-video-installation.html).
On Windows, you can use the DXVA2/D3D11VA libraries for decoding and the libmfx library for encoding.
> [!NOTE]
> To use QSV on Windows, please do not install Jellyfin as a system service.
Issues: [FFmpeg Windows version with QSV hwaccel fails over TERMINAL](https://trac.ffmpeg.org/ticket/7511) and [Intel QSV: "Failed to create Direct3D device" on Core i7-7700K (Skylake) on Windows 10](https://trac.ffmpeg.org/ticket/6827)
CentOS may require [additional drivers](https://www.getpagespeed.com/server-setup/how-to-enable-intel-hardware-acceleration-for-video-playback-in-rhel-centos-8) for QSV.
Here's [additional information](https://github.com/Artiume/jellyfin-docs/blob/master/general/wiki/main.md) to learn more.
If your Jellyfin server does not support hardware acceleration, but you have another machine that does, you can leverage [rffmpeg](https://github.com/joshuaboniface/rffmpeg) to delegate the transcoding to another machine. Currently Linux-only and requires SSH between the machines, as well as shared storage both for media and for the Jellyfin data directory.
## Enabling Hardware Acceleration
Hardware acceleration options can be found in the Admin Dashboard under the **Transcoding** section of the **Playback** tab. Select a valid hardware acceleration option from the drop-down menu, indicate a device if applicable, and check `enable hardware encoding` to enable encoding as well as decoding, if your hardware supports this.
The hardware acceleration is available immediately for media playback. No server restart is required.
## Setup
Each hardware acceleration type, as well as each Jellyfin installation type, requires different setup options before it can be used. It is always best to consult the FFMpeg documentation on the acceleration type you choose for the latest information.
### Acceleration on Docker
In order to use hardware acceleration in Docker, the devices must be passed to the container. To see what video devices are available, you can run `sudo lshw -c video` or `vainfo` on your machine. VAAPI may require the `render` group added to the docker permissions. The `render` group id can be discovered in /etc/group such as `render:x:122:`.
You can use `docker run` to start the server with a command like the one below.
```sh
docker run -d \
--volume /path/to/config:/config \
--volume /path/to/cache:/cache \
--volume /path/to/media:/media \
--user 1000:1000 \
--group-add=122 \
--net=host \
--restart=unless-stopped \
--device /dev/dri/renderD128:/dev/dri/renderD128 \
--device /dev/dri/card0:/dev/dri/card0 \
jellyfin/jellyfin
```
Alternatively, you can use docker-compose with a configuration file so you don't need to run a long command every time you restart your server.
```yaml
version: "3"
services:
jellyfin:
image: jellyfin/jellyfin
user: 1000:1000
group_add:
- 122
network_mode: "host"
volumes:
- /path/to/config:/config
- /path/to/cache:/cache
- /path/to/media:/media
devices:
# VAAPI Devices
- /dev/dri/renderD128:/dev/dri/renderD128
- /dev/dri/card0:/dev/dri/card0
# RPi 4
- /dev/vchiq:/dev/vchiq
```
### Linux Docker NVIDIA NVENC
In order to achieve hardware acceleration using docker, several steps are required.
Prerequisites:
[NVIDIA Container Toolkit installation](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#getting-started)
- GNU/Linux x86_64 with kernel version > 3.10
- Docker >= 19.03
- NVIDIA GPU with Architecture > Fermi (2.1)
- NVIDIA drivers >= 361.93
Follow the instructions in the link above to install the NVIDIA Container Toolkit for your Linux distribution.
Start your container adding these parameters:
```sh
-e NVIDIA_DRIVER_CAPABILITIES=all \
-e NVIDIA_VISIBLE_DEVICES=all \
--gpus all \
```
A complete run command would look like this:
```sh
docker run -d \
--name=jellyfin \
-e NVIDIA_DRIVER_CAPABILITIES=all \
-e NVIDIA_VISIBLE_DEVICES=all \
--gpus all \
-p 8096:8096 \
-p 8920:8920 \
-v /config:/config \
-v /media:/media \
-v /cache:/cache \
--restart unless-stopped \
jellyfin/jellyfin
```
Or with docker-compose >1.28, add the `deploy` and `environment` parts to your Jellyfin service:
```yaml
services:
jellyfin:
image: jellyfin/jellyfin
# ... your Jellyfin config
environment:
NVIDIA_DRIVER_CAPABILITIES: all
NVIDIA_VISIBLE_DEVICES: all
deploy:
resources:
reservations:
devices:
- capabilities: [gpu]
```
There are some special steps when running with the following option:
```sh
--user 1000:1000
```
You may need to add this user to the video group on your host machine:
```sh
usermod -aG video user
```
Once the container is started you can again validate access to the host resources:
```sh
docker exec -it jellyfin nvidia-smi
```
If you get driver information, everything is fine but if you get an error like `couldn't find libnvidia-ml.so library in your system` you need to run the following command:
```sh
docker exec -it jellyfin ldconfig
```
After that, you should ensure the NVIDIA driver loads correctly.
### Configuring OpenCL Accelerated/VPP Tone Mapping
OpenCL tone mapping with NVIDIA NVENC, AMD AMF, and Intel VAAPI is through OpenCL image support.
Full hardware based VPP tonemapping is supported on Intel VAAPI and QSV on Linux.
OS/Platform | NVIDIA NVENC | AMD AMF | Intel VAAPI | AMD VAAPI | Intel QSV | Software
----------- | ------------ | -------- | ----------- | --------- | --------- | --------
Linux | OK | OK | OK | planned | OK | planned
Windows | OK | OK | N/A | N/A | planned | planned
Docker | OK | untested | OK | planned | planned | planned
> [!NOTE]
> Make sure the hardware acceleration is well configured before reading this section.
1. On Windows: Install the latest NVIDIA or AMD drivers.
2. On Linux or docker:
- For NVIDIA cards, install `nvidia-opencl-icd` on Debian/Ubuntu:
```sh
sudo apt update
sudo apt install nvidia-opencl-icd
```
If presented with multiple package options, choose the one that matches the version of your current nvidia driver (`apt list --installed | grep nvidia`).
Install `opencl-nvidia` on Arch:
```sh
sudo pacman -Sy opencl-nvidia
```
- For AMD cards, install `amdgpu-pro` with opencl arguments. See **Configuring AMD AMF encoding on Ubuntu 18.04 or 20.04 LTS** for more details.
```sh
sudo ./amdgpu-pro-install -y --opencl=pal,legacy
```
- For Intel iGPUs, you have two types of tonemapping methods: OpenCL and VPP. Choose the latter one for faster transcoding speed, but fine tuning options are not supported.
Method OpenCL: Follow the instructions from [intel-compute-runtime](https://github.com/intel/compute-runtime/releases). If you are using the docker image from jellyfin/jellyfin or linuxserver/jellyfin, this step can be skipped.
Method VPP: Install `intel-media-va-driver-non-free` 20.1 and `jellyfin-ffmpeg` 4.3.1-4 or newer.
> [!NOTE]
> Tone mapping on Intel VAAPI and QSV needs an iGPU that supports 10-bit decoding, such as i3-7100 and J4105.
> Do not use the `intel-opencl-icd` package from the repository since they were not build with RELEASE_WITH_REGKEYS enabled for P010 pixel interop flags.
3. Check the OpenCL device status. You will see corresponding vendor name if it goes well.
- Use `clinfo`: Install `clinfo` before using it. `sudo apt update && sudo apt install clinfo -y` on Debian/Ubuntu or `sudo pacman -Sy clinfo` on Arch. Then `sudo clinfo`
- Use `jellyfin-ffmpeg`: `/usr/lib/jellyfin-ffmpeg/ffmpeg -v debug -init_hw_device opencl`
### Configuring VAAPI acceleration on Debian/Ubuntu from `.deb` packages
Configuring VAAPI on Debian/Ubuntu requires some additional configuration to ensure permissions are correct.
To check information about VAAPI on your system install and run `vainfo` from the command line.
> [!NOTE]
> For Intel Comet Lake or newer iGPUs, the legacy i965 VAAPI driver is incompatible with your hardware.
> Please follow the instructions from **Configuring Intel QuickSync(QSV) on Debian/Ubuntu** to get the newer iHD driver.
1. Configure VAAPI for your system by following the [relevant documentation](https://wiki.archlinux.org/index.php/Hardware_video_acceleration). Verify that a `render` device is now present in `/dev/dri`, and note the permissions and group available to write to it, in this case `render`:
```sh
$ ls -l /dev/dri
total 0
drwxr-xr-x 2 root root 100 Apr 13 16:37 by-path
crw-rw---- 1 root video 226, 0 Apr 13 16:37 card0
crw-rw---- 1 root video 226, 1 Apr 13 16:37 card1
crw-rw---- 1 root render 226, 128 Apr 13 16:37 renderD128
```
> [!NOTE]
> On some releases, the group may be `video` instead of `render`.
2. Add the Jellyfin service user to the above group to allow Jellyfin's FFMpeg process access to the device, and restart Jellyfin.
```sh
sudo usermod -aG render jellyfin
sudo systemctl restart jellyfin
```
3. Configure VAAPI acceleration in the "Transcoding" page of the Admin Dashboard. Enter the `/dev/dri/renderD128` device above as the `VA API Device` value.
4. Watch a movie, and verify that transcoding is occurring by watching the `ffmpeg-transcode-*.txt` logs under `/var/log/jellyfin` and using `radeontop` or similar tools.
### Configuring Intel QuickSync(QSV) on Debian/Ubuntu
1. QSV is based on VAAPI device on Linux, so please confirm whether you have completed the VAAPI configuration first.
2. Make sure that `jellyfin-ffmpeg 4.3.1-1` or higher is installed.
3. Install the non-free iHD driver.
```bash
sudo apt update
sudo apt install vainfo intel-media-va-driver-non-free -y
```
> [!NOTE]
> For Intel Comet Lake or newer iGPUs, make sure the version of `intel-media-va-driver-non-free` >= 19.1.
> `intel-media-va-driver-non-free` is avaliable from apt since Debian buster and Ubuntu 19.04. Otherwise you have to build from source.
4. Verify iHD driver using `vainfo`. You will find `iHD` from the result if it goes well.
```bash
vainfo | grep iHD
```
5. If you want to uninstall iHD driver and fallback to i965 driver.
```bash
sudo apt remove intel-media-va-driver intel-media-va-driver-non-free -y
```
6. QSV in docker. Due to incompatible licenses, we will not integrate non-free drivers in the docker image. You need to perform the above operations manually in docker and add `--privileged` to the docker configuration.
### LXC or LXD Container
This has been tested with LXC 3.0 and may or may not work with older versions.
Follow the steps above to add the jellyfin user to the `video` or `render` group, depending on your circumstances.
1. Add your GPU to the container.
```sh
lxc config device add <container name> gpu gpu gid=<gid of your video or render group>
```
2. Make sure you have the card within the container:
```sh
$ lxc exec jellyfin -- ls -l /dev/dri
total 0
crw-rw---- 1 root video 226, 0 Jun 4 02:13 card0
crw-rw---- 1 root video 226, 0 Jun 4 02:13 controlD64
crw-rw---- 1 root video 226, 128 Jun 4 02:13 renderD128
```
3. Configure Jellyfin to use video acceleration and point it at the right device if the default option is wrong.
4. Try and play a video that requires transcoding and run the following, you should get a hit.
```sh
ps aux | grep ffmpeg | grep accel
```
5. You can also try playing a video that requires transcoding, and if it plays you're good.
Useful Resources:
- [LXD Documentation - GPU instance configuration](https://github.com/lxc/lxd/blob/master/doc/instances.md#type-gpu)
- [NVidia CUDA inside a LXD container](https://stgraber.org/2017/03/21/cuda-in-lxd/)
### Configuring AMD AMF encoding on Ubuntu 18.04 or 20.04 LTS
1. Install `amdgpu-pro` closed source graphics driver by following the [installation instructions](https://amdgpu-install.readthedocs.io/en/latest/).
2. Then install `amf-amdgpu-pro`.
```bash
sudo apt install amf-amdgpu-pro
```
3. Make sure your `jellyfin-ffmpeg` or `ffmpeg` contains `h264_amf` encoder.
```bash
$ cd /usr/lib/jellyfin-ffmpeg/
$ ./ffmpeg -encoders | grep h264_amf
V..... h264_amf AMD AMF H.264 Encoder (codec h264)
```
> [!NOTE]
> If not contain, update your `jellyfin-ffmpeg` to the latest version and try again.
For compiling ffmpeg with AMF library, refer to [this page](https://www.ffmpeg.org/general.html#AMD-AMF_002fVCE).
4. Choose AMD AMF video acceleration in Jellyfin and check the `Enable hardware encoding` option.
5. Watch a movie, then verify that `h264_amf` encoder is working by watching the `ffmpeg-transcode-*.txt` transcoding logs under `/var/log/jellyfin` and using `radeontop` or similar tools.
### Configuring AMD AMF encoding on Arch Linux
AMD does not provide official `amdgpu-pro` driver support for Arch Linux, but fortunately, a third-party packaged `amdgpu-pro-installer` is provided in the archlinux user repository.
1. Clone [this repository](https://aur.archlinux.org/pkgbase/amdgpu-pro-installer/) using `git`.
```bash
git clone https://aur.archlinux.org/amdgpu-pro-installer.git
```
2. Enter that folder and make the installation package and install it.
```bash
cd amdgpu-pro-installer
makepkg -si
```
3. Go to step 3 of **on Ubuntu 18.04 or 20.04 LTS** above.
### Raspberry Pi 3 and 4
1. Add the Jellyfin service user to the video group to allow Jellyfin's FFMpeg process access to the encoder, and restart Jellyfin.
```sh
sudo usermod -aG video jellyfin
sudo systemctl restart jellyfin
```
> [!NOTE]
> If you are using a Raspberry Pi 4, you might need to run `sudo rpi-update` for kernel and firmware updates.
2. Choose `OpenMAX OMX` as the Hardware acceleration on the Transcoding tab of the Server Dashboard.
3. Change the amount of memory allocated to the GPU. The GPU can't handle accelerated decoding and encoding simultaneously.
```sh
sudo nano /boot/config.txt
```
For RPi4, add the line `gpu_mem=320` [See more Here](https://www.raspberrypi.org/documentation/configuration/config-txt/)
For RPi3, add the line `gpu_mem=256`
You can set any value, but 320 is recommended amount for [4K HEVC](https://github.com/CoreELEC/CoreELEC/blob/coreelec-9.2/projects/RPi/devices/RPi4/config/config.txt).
Verify the split between CPU and GPU memory:
```sh
vcgencmd get_mem arm && vcgencmd get_mem gpu
```
Monitor the temperature and clock speed of the CPU:
```sh
vcgencmd measure_temp && vcgencmd measure_clock arm
```
> [!NOTE]
> RPi4 currently doesn't support HWA HEVC decoding, only encode and decode H.264. [Active cooling](https://www.jeffgeerling.com/blog/2019/raspberry-pi-4-needs-fan-heres-why-and-how-you-can-add-one) is required, passive cooling is insufficient for transcoding. Only Raspbian OS works so far. For docker, only the linuxserver image works. For more tips see [here](https://www.reddit.com/r/jellyfin/comments/ei6ew6/rpi4_hardware_acceleration_guide/).
> [!NOTE]
> For RPi3 in testing, transcoding was not working fast enough to run in real time because the video was being resized.
## Verifying Transcodes
To verify that you are using the proper libraries, run this command against your transcoding log. This can be found at Admin Dashboard > Logs, and /var/log/jellyfin if instead via the repository.
```sh
grep -A2 'Stream mapping:' /var/log/jellyfin/ffmpeg-transcode-85a68972-7129-474c-9c5d-2d9949021b44.txt
```
This returned the following results.
```data
Stream mapping:
Stream #0:0 -> #0:0 (hevc (native) -> h264 (h264_omx))
Stream #0:1 -> #0:1 (aac (native) -> mp3 (libmp3lame))
```
`Stream #0:0` used software (VAAPI Decode can also say native) to decode HEVC and used HWA to encode.
```data
Stream mapping:
Stream #0:0 -> #0:0 (h264 (h264_mmal) -> h264 (h264_omx))
Stream #0:1 -> #0:1 (flac (native) -> mp3 (libmp3lame))
```
`Stream #0:0` used HWA for both. h264_mmal to decode and h264_omx to encode.

133
docs/configuration/networking.md
View File

@ -1,133 +0,0 @@
---
id: networking
title: Networking
---
# Networking
This section describes how to get basic connectivity to a Jellyfin server, and also some more advanced networking scenarios.
## Connectivity
Many clients will automatically discover servers running on the same LAN and display them on login. If you are outside the network when you connect you can type in the complete IP address or domain name in the server field with the correct port to continue to the login page. You can find the default ports below to access the web frontend.
HTTP and HTTPS are the primary means of connecting to the server. If using a self-signed certificate for HTTPS, some clients may not work such as Chromecast or Roku.
> [!WARNING]
> In order for Chromecast to work on a non-public routable connection, 8.8.8.8 must be blocked on the Chromecast's Gateway. Blocking 8.8.8.8 on your router is the easiest solution to this problem.
### Port Bindings
This document aims to provide an administrator with knowledge on what ports Jellyfin binds to and what purpose they serve.
#### Static Ports
* 8096/tcp is used by default for HTTP traffic. You can change this in the dashboard.
* 8920/tcp is used by default for HTTPS traffic. You can change this in the dashboard.
* 1900/udp is used for service auto-discovery. This is not configurable.
* 7359/udp is also used for auto-discovery. This is not configurable.
**HTTP Traffic:** 8096
The web frontend can be accessed here for debugging SSL certificate issues on your local network. You can modify this setting from the **Networking** page in the settings.
**HTTPS Traffic:** 8920
This setting can also be modified from the **Networking** page to use a different port.
**Service Discovery:** 1900
Since client auto-discover would break if this option were configurable, you cannot change this in the settings at this time. DLNA also uses this port and is required to be in the local subnet.
**Client Discovery:** 7359 UDP
Allows clients to discover Jellyfin on the local network. A broadcast message to this port with `Who is JellyfinServer?` will get a JSON response that includes the server address, ID, and name.
#### Dynamic Ports
Live TV devices will often use a random UDP port for HDHomeRun devices. The server will select an unused port on startup to connect to these tuner devices.
### Monitoring Endpoints
See @monitoring for details on the monitoring endpoints that Jellyfin provides.
## Self-Signed Certificate
[See here for more information.](https://www.sslshopper.com/article-most-common-openssl-commands.html)
Create a private key.
```sh
openssl req -x509 -newkey rsa:4096 -keyout ./privkey.pem -out cert.pem -days 365 -nodes -subj '/CN=jellyfin.lan'
```
Omit `-nodes` to set a password interactively.
Remove `-days 365` to make it 'permanent'.
Add `-subj '/CN=localhost'` to make it not ask interactive questions about content of certificate.
The above command creates `./privkey.pem` which will require one more step before use in Jellyfin.
```sh
openssl pkcs12 -export -out jellyfin.pfx -inkey privkey.pem -in /usr/local/etc/letsencrypt/live/domain.org/cert.pem -passout pass:
```
## Running Jellyfin Behind a Reverse Proxy
It's possible to run Jellyfin behind another server acting as a reverse proxy. With a reverse proxy setup, this server handles all network traffic and proxies it back to Jellyfin. This provides the benefits of using DNS names and not having to remember port numbers, as well as easier integration and management of SSL certificates.
> [!WARNING]
> In order for a reverse proxy to have the maximum benefit, you should have a publically routable IP address and a domain with DNS set up correctly.
> These examples assume you want to run Jellyfin under a sub-domain (e.g. jellyfin.example.com), but are easily adapted for the root domain if desired.
Some popular options for reverse proxy systems are [Apache](https://httpd.apache.org), [Caddy](https://caddyserver.com), [Haproxy](https://www.haproxy.com), [Nginx](https://www.nginx.com) and [Traefik](https://traefik.io).
* [Apache](xref:network-reverse-proxy-apache)
* [Caddy](xref:network-reverse-proxy-caddy)
* [HAProxy](xref:network-reverse-proxy-haproxy)
* [Nginx](xref:network-reverse-proxy-nginx)
* [Traefik](xref:network-reverse-proxy-traefik)
While not a reverse proxy, Let's Encrypt can be used independently or with a reverse proxy to provide SSL certificates.
* [Let's Encrypt](xref:network-letsencrypt)
When following this guide, be sure to replace the following variables with your information.
* `DOMAIN_NAME`: Your public domain name to access Jellyfin on (e.g. jellyfin.example.com)
* `example.com`: The domain name Jellyfin services will run under (e.g. example.com)
* `SERVER_IP_ADDRESS`: The IP address of your Jellyfin server (if the reverse proxy is on the same server use 127.0.0.1)
In addition, the examples are configured for use with Let's Encrypt certificates. If you have a certificate from another source, change the SSL configuration from `/etc/letsencrypt/DOMAIN_NAME/` to the location of your certificate and key.
Ports 80 and 443 (pointing to the proxy server) need to be opened on your router and firewall.
### Known Proxies
Add the IP address/hostname of your reverse proxy to the `Known Proxies` (under Admin Dashboard -> Networking). This is a comma separated list of IP addresses/hostnames of known proxies used when connecting to your Jellyfin instance and is required to make proper use of X-Forwarded-For headers. Requires a server restart after saving.
### Base URL
Running Jellyfin with a path (e.g. `https://example.com/jellyfin`) is supported by the Android and web clients.
> [!WARNING]
> Base URL is known to break HDHomeRun, DLNA, Sonarr, Radarr, Chromecast, and MrMC.
The Base URL setting in the **Networking** page is an advanced setting used to specify the URL prefix that your Jellyfin instance can be accessed at. In effect, it adds this URL fragment to the start of any URL path. For instance, if you have a Jellyfin server at `http://myserver` and access its main page `http://myserver/web/index.html`, setting a Base URL of `/jellyfin` will alter this main page to `http://myserver/jellyfin/web/index.html`. This can be useful if administrators want to access multiple Jellyfin instances under a single domain name, or if the Jellyfin instance lives only at a subpath to another domain with other services listening on `/`.
The entered value on the configuration page will be normalized to include a leading `/` if this is missing.
This setting requires a server restart to change, in order to avoid invalidating existing paths until the administrator is ready.
There are three main caveats to this setting.
1. When setting a new Base URL (i.e. from `/` to `/baseurl`) or changing a Base URL (i.e. from `/baseurl` to `/newbaseurl`), the Jellyfin web server will automatically handle redirects to avoid displaying users invalid pages. For instance, accessing a server with a Base URL of `/jellyfin` on the `/` path will automatically append the `/jellyfin` Base URL. However, entirely removing a Base URL (i.e. from `/baseurl` to `/`, an empty value in the configuration) will not - all URLs with the old Base URL path will become invalid and throw 404 errors. This should be kept in mind when removing an existing Base URL.
2. Client applications generally, for now, do not handle the Base URL redirects implicitly. Therefore, for instance in the Android app, the `Host` setting *must* include the BaseURL as well (e.g. `http://myserver:8096/baseurl`), or the connection will fail.
3. Any reverse proxy configurations must be updated to handle a new Base URL. Generally, passing `/` back to the Jellyfin instance will work fine in all cases and the paths will be normalized, and this is the standard configuration in our examples. Keep this in mind however when doing more advanced routing.
### Final Steps
It's strongly recommend that you check your SSL strength and server security at [SSLLabs](https://www.ssllabs.com/ssltest/analyze.html) if you are exposing these services to the internet.

74
docs/configuration/troubleshooting.md
View File

@ -1,74 +0,0 @@
---
id: admin-troubleshoot
title: Troubleshooting
---
# Troubleshooting
This page outlines some solutions to common issues beginners may encounter when running a Jellyfin server.
## Playback Issues
The easiest way to check for issues is by checking the logs, which can be accessed through the console for the web client or in the log directory on your server.
If media is unable transcode, first check the ffmpeg logs.
## Networking Issues
If you can access the web interface over HTTP but not HTTPS, then you likely have an error with the certificate. Jellyfin uses a PFX file to handle HTTPS traffic. If you created the file with a password, then you will have to enter that value on the **Networking** page in the settings.
If you can access the server locally but not outside of your LAN, then you likely have an issue with the router configuration. Check the port forwarding settings on your router to ensure the server is visible from outside your local network. You can also enable the "Enable automatic port mapping" option on the **Networking** page of the server settings to have the server attempt to configure port forwarding on the router automatically if your router supports it.
If there are no logs at all relating to web traffic, even over a LAN connection, then the server hasn't been reached at all yet. This would indicate either an incorrect address or an issue somewhere else on the network.
## Debug Logging
To enable debug (much more verbose) logging, it is currently required to manually edit config files since no options exist yet on the frontend. Go to the Jellyfin configuration directory, find the `logging.default.json` file, and change the minimum level to debug as seen below.
```json
{
"Serilog": {
"MinimumLevel": {
"Default": "Debug"
}
}
}
```
Jellyfin will automatically reload the new configuration without needing to restart. The debug messages show up in the log with the `DBG` tag.
## Real Time Monitoring
This will let Jellyfin automatically update libraries when files are added or modified. Unfortunately this feature is only supported on certain filesystems.
For Linux systems, this is performed by [inotify](https://en.wikipedia.org/wiki/Inotify). NFS and rclone do not support inotify, but support can be provided by using a union file system such as [mergerfs](https://github.com/trapexit/mergerfs) with your networked file systems.
Due to the library size, you can receive an error such as this:
```log
[2019-12-31 09:11:36.652 -05:00] [ERR] Error in Directory watcher for: "/media/movies" System.IO.IOException: The configured user limit (8192) on the number of inotify watches has been reached.
```
If you are running Debian, RedHat, or another similar Linux distribution, run the following in a terminal:
```sh
echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p
```
If you are running ArchLinux, run the following command instead:
```sh
echo fs.inotify.max_user_watches=524288 | sudo tee /etc/sysctl.d/40-max-user-watches.conf && sudo sysctl --system
```
Then paste it in your terminal and press on enter to run it. For Docker, this needs to be done on the host, not the container. See [here](https://github.com/guard/listen/wiki/Increasing-the-amount-of-inotify-watchers) for more information.
## Uninstall MacOS
To fully remove all data of Jellyfin from MacOS, run these commands:
```bash
rm -Rfv ~/.config/jellyfin
rm -Rfv ~/.cache/jellyfin
rm -Rfv ~/.local/share/jellyfin
```

27
docs/getting-started.md
View File

@ -1,27 +0,0 @@
---
id: getting-started
title: Getting started
sidebar_position: 1
---
## What is Jellyfin?
Jellyfin is a free and open source media server. It enables you to access your media from anywhere, on any device.
## Install Jellyfin
1. Install the Jellyfin server on [your compoer](xref:admin-installing) or [compatible NAS device](#).
2. Browse to `http://SERVER_IP:8096` to access the included web client.
3. Setup your server and add media to your libraries.
4. Setup a [reverse proxy](networking/index.md#running-jellyfin-behind-a-reverse-proxy) for accessing Jellyfin securely from anywhere.
5. Press Play and enjoy your media on any device, without compromising your privacy!
## Where does Jellyfin work?
The Jellyfin server can be installed on [Windows](#), [macOS](#), [Linux](#), [as a container](#) or any [compatible NAS device](#).
Clients, both official and third party, are available for multiple platforms and devices. Please see the [Clients page](/clients) for a list of available clients.

897
docs/installing.md
View File

@ -1,897 +0,0 @@
---
id: installing-jellyfin
title: Installing the server
sidebar_position: 2
---
The Jellyfin project and its contributors offer a number of pre-built binary packages to assist in getting Jellyfin up and running quickly on multiple systems.
## Container images
Official container image: `jellyfin/jellyfin` <a href="https://hub.docker.com/r/jellyfin/jellyfin"><img alt="Docker Pull Count" src="https://img.shields.io/docker/pulls/jellyfin/jellyfin.svg" /></a>.
LinuxServer.io image: `linuxserver/jellyfin` <a href="https://hub.docker.com/r/linuxserver/jellyfin"><img alt="Docker Pull Count" src="https://img.shields.io/docker/pulls/linuxserver/jellyfin.svg" /></a>.
hotio image: `hotio/jellyfin` <a href="https://hub.docker.com/r/hotio/jellyfin"><img alt="Docker Pull Count" src="https://img.shields.io/docker/pulls/hotio/jellyfin.svg" /></a>.
Jellyfin distributes [official container images on Docker Hub](https://hub.docker.com/r/jellyfin/jellyfin/) for multiple architectures. These images are based on Debian and [built directly from the Jellyfin source code](https://github.com/jellyfin/jellyfin/blob/master/Dockerfile).
Additionally the [LinuxServer.io](https://www.linuxserver.io/) project and [hotio](https://github.com/hotio) distribute images based on Ubuntu and the official Jellyfin Ubuntu binary packages, see [here](https://github.com/linuxserver/docker-jellyfin/blob/master/Dockerfile) and [here](https://github.com/hotio/docker-jellyfin/blob/stable/linux-amd64.Dockerfile) to see their Dockerfile.
:::note
For ARM hardware and RPi, it is recommended to use the LinuxServer.io or hotio image since hardware acceleration support is not yet available on the native image.
:::
### Docker
[Docker](https://www.docker.com/) allows you to run containers on Linux, Windows and MacOS.
The basic steps to create and run a Jellyfin container using Docker are as follows.
1. Follow the [offical installation guide to install Docker](https://docs.docker.com/engine/install).
2. Download the latest container image.
```sh
docker pull jellyfin/jellyfin
```
3. Create persistent storage for configuration and cache data.
Either create two persistent volumes:
```sh
docker volume create jellyfin-config
docker volume create jellyfin-cache
```
Or create two directories on the host and use bind mounts:
```sh
mkdir /path/to/config
mkdir /path/to/cache
```
4. Create and run a container in one of the following ways.
:::note
The default network mode for Docker is bridge mode. Bridge mode will be used if host mode is omitted. Use host mode for networking in order to use DLNA or an HDHomeRun.
:::
**Using Docker command line interface:**
```sh
docker run -d \
--name jellyfin \
--user id:gid \
--net=host \
--volume /path/to/config:/config \
--volume /path/to/cache:/cache \
--mount type=bind,source=/path/to/media,target=/media \
--restart=unless-stopped \
jellyfin/jellyfin
```
Using host networking (`--net=host`) is optional but required in order to use DLNA or HDHomeRun.
Bind Mounts are needed to pass folders from the host OS to the container OS whereas volumes are maintained by Docker and can be considered easier to backup and control by external programs. For a simple setup, it's considered easier to use Bind Mounts instead of volumes. Replace `jellyfin-config` and `jellyfin-cache` with `/path/to/config` and `/path/to/cache` respectively if using bind mounts. Multiple media libraries can be bind mounted if needed:
```sh
--mount type=bind,source=/path/to/media1,target=/media1
--mount type=bind,source=/path/to/media2,target=/media2,readonly
...etc
```
:::note
There is currently an [issue](https://github.com/docker/for-linux/issues/788) with read-only mounts in Docker. If there are submounts within the main mount, the submounts are read-write capable.
:::
**Using Docker Compose:**
Create a `docker-compose.yml` file with the following contents:
```yml
version: "3.5"
services:
jellyfin:
image: jellyfin/jellyfin
container_name: jellyfin
user: id:gid
network_mode: "host"
volumes:
- /path/to/config:/config
- /path/to/cache:/cache
- /path/to/media:/media
- /path/to/media2:/media2:ro
restart: "unless-stopped"
# Optional - alternative address used for autodiscovery
environment:
- JELLYFIN_PublishedServerUrl=http://example.com
```
Then while in the same folder as the `docker-compose.yml` run:
```sh
docker-compose up
```
To run the container in background add `-d` to the above command.
You can learn more about using Docker by [reading the official Docker documentation](https://docs.docker.com/).
### Unraid Docker
An Unraid Docker template is available in the repository.
1. Open the unRaid GUI (at least unRaid 6.5) and click on the "Docker" tab.
2. Add the following line under "Template Repositories" and save the options.
```data
https://github.com/jellyfin/jellyfin/blob/master/deployment/unraid/docker-templates
```
3. Click "Add Container" and select "jellyfin".
4. Adjust any required paths and save your changes.
### Kubernetes
A community project to deploy Jellyfin on Kubernetes-based platforms exists [at their repository](https://github.com/home-cluster/jellyfin-openshift). Any issues or feature requests related to deployment on Kubernetes-based platforms should be filed there.
### Podman
[Podman](https://podman.io) allows you to run containers as non-root. It's also the offically supported container solution on RHEL and CentOS.
Steps to run Jellyfin using Podman are almost identical to Docker steps:
1. Install Podman:
```sh
dnf install -y podman
```
Installing
podman volume create jellyfin-cache
```
Or create two directories on the host and use bind mounts:
```sh
mkdir /path/to/config
mkdir /path/to/cache
```
4. Create and run a Jellyfin container:
```sh
podman run \
--cgroup-manager=systemd \
--volume jellyfin-config:/config \
--volume jellyfin-cache:/cache \
--volume jellyfin-media:/media \
-p 8096:8096 \
--label "io.containers.autoupdate=image" \
--name myjellyfin \
jellyfin/jellyfin
```
Note that Podman doesn't require root access and it's recommended to run the Jellyfin container as a separate non-root user for security.
Keep in mind that the `--label "io.containers.autoupdate=image"` flag will allow the container to be automatically updated via `podman auto-update`.
If SELinux is enabled you need to use either the `z` (shared volume) or `Z` (private volume) volume option to allow Jellyfin to access the volumes.
Replace `jellyfin-config`, `jellyfin-cache`, and `jellyfin-media` with `/path/to/config`, `/path/to/cache` and `/path/to/media` respectively if using bind mounts.
To mount your media library read-only append ':ro' to the media volume:
```sh
--volume /path/to/media:/media:ro
```
#### Managing via Systemd
To run as a systemd service see [Running containers with Podman and shareable systemd services](https://www.redhat.com/sysadmin/podman-shareable-systemd-services).
As always it is recommended to run the container rootless. Therefore we want to manage the container with the `systemd --user` flag.
1. First we have to generate the container as seen above.
2. Next generate the systemd.service file.
```sh
podman generate systemd --new --name myjellyfin > ~/.config/systemd/user/container-myjellyfin.service
```
3. Verify and edit the systemd.service file to your liking. To further sandbox see [Mastering systemd: Securing and sandboxing applications and services](https://www.redhat.com/sysadmin/mastering-systemd). An example service file is shown below. **Do not blindly copy**, one should make edits to the service file generated by podman.
```sh
# container-myjellyfin.service
# autogenerated by Podman 2.2.1
# Wed Feb 17 23:49:24 EST 2021
[Unit]
Description=Podman container-myjellyfin.service
Documentation=man:podman-generate-systemd(1)
Wants=network.target
After=network-online.target
[Service]
Environment=PODMAN_SYSTEMD_UNIT=%n
Restart=on-failure
ExecStartPre=/bin/rm -f %t/container-myjellyfin.pid %t/container-myjellyfin.ctr-id
ExecStart=/usr/bin/podman run --conmon-pidfile %t/container-myjellyfin.pid --cidfile %t/container-myjellyfin.ctr-id --cgroups=no-conmon -d --replace --cgroup-manager=systemd --volume jellyfin-config:/config:z --volume jellyfin-cache:/cache:z --volume jellyfin-media:/media:z -p 8096:8096 --userns keep-id --name myjellyfin jellyfin/jellyfin
ExecStop=/usr/bin/podman stop --ignore --cidfile %t/container-myjellyfin.ctr-id -t 10
ExecStopPost=/usr/bin/podman rm --ignore -f --cidfile %t/container-myjellyfin.ctr-id
PIDFile=%t/container-myjellyfin.pid
KillMode=control-group
Type=forking
# Security Features
PrivateTmp=yes
NoNewPrivileges=yes
ProtectSystem=strict
ProtectHome=yes
ProtectKernelTunables=yes
ProtectControlGroups=yes
PrivateMounts=yes
ProtectHostname=yes
[Install]
WantedBy=multi-user.target default.target
```
4. Enable the service.
```sh
systemctl --user enable container-myjellyfin.service
```
At this point the container will only start when the user logs in and shutdown when they log off. To have the container start as the user at first login we'll have to include one more option.
```sh
loginctl enable-linger <username>
```
5. Start the service.
```sh
systemctl --user start container-myjellyfin.service
```
### Cloudron
Cloudron is a complete solution for running apps on your server and keeping them up-to-date and secure. On your Cloudron you can install Jellyfin with a few clicks via the [app library](https://cloudron.io/store/org.jellyfin.cloudronapp.html) and updates are delivered automatically.
The source code for the package can be found [here](https://git.cloudron.io/cloudron/jellyfin-app).
Any issues or feature requests related to deployment on Cloudron should be filed there.
## Windows (x86/x64)
Windows installers and builds in ZIP archive format are available [here](https://jellyfin.org/downloads/#windows).
:::warning
If you installed a version prior to 10.4.0 using a PowerShell script, you will need to manually remove the service using the command `nssm remove Jellyfin` and uninstall the server by remove all the files manually. Also one might need to move the data files to the correct location, or point the installer at the old location.
:::
:::warning
The 32-bit or x86 version is not recommended. `ffmpeg` and its video encoders generally perform better as a 64-bit executable due to the extra registers provided. This means that the 32-bit version of Jellyfin is deprecated.
:::
### Install using Installer (x64)
**Install**
1. Download the latest version.
2. Run the installer.
3. (Optional) When installing as a service, pick the service account type.
4. If everything was completed successfully, the Jellyfin service is now running.
5. Open your browser at <http://localhost:8096> to finish setting up Jellyfin.
**Update**
1. Download the latest version.
2. Run the installer.
3. If everything was completed successfully, the Jellyfin service is now running as the new version.
**Uninstall**
1. Go to `Add or remove programs` in Windows.
2. Search for Jellyfin.
3. Click Uninstall.
### Manual Installation (x86/x64)
**Install**
1. Download and extract the latest version.
1. Create a folder `jellyfin` at your preferred install location.
1. Copy the extracted folder into the `jellyfin` folder and rename it to `system`.
1. Create `jellyfin.bat` within your `jellyfin` folder containing:
- To use the default library/data location at `%localappdata%`:
```cmd
<--Your install path-->\jellyfin\system\jellyfin.exe
```
- To use a custom library/data location (Path after the -d parameter):
```cmd
<--Your install path-->\jellyfin\system\jellyfin.exe -d <--Your install path-->\jellyfin\data
```
- To use a custom library/data location (Path after the -d parameter) and disable the auto-start of the webapp:
```cmd
<--Your install path-->\jellyfin\system\jellyfin.exe -d <--Your install path-->\jellyfin\data -noautorunwebapp
```
1. Run
```cmd
jellyfin.bat
```
1. Open your browser at `http://<--Server-IP-->:8096` (if auto-start of webapp is disabled)
**Update**
1. Stop Jellyfin
2. Rename the Jellyfin `system` folder to `system-bak`
3. Download and extract the latest Jellyfin version
4. Copy the extracted folder into the `jellyfin` folder and rename it to `system`
5. Run `jellyfin.bat` to start the server again
**Rollback**
1. Stop Jellyfin.
2. Delete the `system` folder.
3. Rename `system-bak` to `system`.
4. Run `jellyfin.bat` to start the server again.
## MacOS
MacOS Application packages and builds in TAR archive format are available [here](https://jellyfin.org/downloads/#macos).
**Install**
1. Download the latest version.
2. Drag the `.app` package into the Applications folder.
3. Start the application.
4. Open your browser at `http://127.0.0.1:8096`.
**Upgrade**
1. Download the latest version.
2. Stop the currently running server either via the dashboard or using the application icon.
3. Drag the new `.app` package into the Applications folder and click yes to replace the files.
4. Start the application.
5. Open your browser at `http://127.0.0.1:8096`.
**Uninstall**
1. Stop the currently running server either via the dashboard or using the application icon.
2. Move the `.app` package to the trash.
**Deleting Configuation**
This will delete all settings and user information. This applies for the .app package and the portable version.
1. Delete the folder `~/.config/jellyfin/`
2. Delete the folder `~/.local/share/jellyfin/`
**Portable Version**
1. Download the latest version
2. Extract it into the Applications folder
3. Open Terminal and type `cd` followed with a space then drag the jellyfin folder into the terminal.
4. Type `./jellyfin` to run jellyfin.
5. Open your browser at <http://localhost:8096>
Closing the terminal window will end Jellyfin. Running Jellyfin in screen or tmux can prevent this from happening.
**Upgrading the Portable Version**
1. Download the latest version.
1. Stop the currently running server either via the dashboard or using `CTRL+C` in the terminal window.
1. Extract the latest version into Applications
1. Open Terminal and type `cd` followed with a space then drag the jellyfin folder into the terminal.
1. Type `./jellyfin` to run jellyfin.
1. Open your browser at <http://localhost:8096>
**Uninstalling the Portable Version**
1. Stop the currently running server either via the dashboard or using `CTRL+C` in the terminal window.
1. Move `/Application/jellyfin-version` folder to the Trash. Replace version with the actual version number you are trying to delete.
**Using FFmpeg with the Portable Version**
The portable version doesn't come with FFmpeg by default, so to install FFmpeg you have three options.
- use the package manager homebrew by typing `brew install ffmpeg` into your Terminal ([here's how to install homebrew if you don't have it already](https://treehouse.github.io/installation-guides/mac/homebrew)
- download the most recent static build from [this link](https://evermeet.cx/ffmpeg/get/zip) (compiled by a third party see [this page](https://evermeet.cx/ffmpeg/) for options and information), or
- compile from source available from the official [website](https://ffmpeg.org/download.html)
More detailed download options, documentation, and signatures can be found.
If using static build, extract it to the `/Applications/` folder.
Navigate to the Playback tab in the Dashboard and set the path to FFmpeg under FFmpeg Path.
## Linux
### Linux (generic amd64)
Generic amd64 Linux builds in TAR archive format are available [here](https://jellyfin.org/downloads/#linux).
#### Installation Process
Create a directory in `/opt` for jellyfin and its files, and enter that directory.
```sh
sudo mkdir /opt/jellyfin
cd /opt/jellyfin
```
Download the latest generic Linux build from the [release page](https://github.com/jellyfin/jellyfin/releases). The generic Linux build ends with "`linux-amd64.tar.gz`". The rest of these instructions assume version 10.4.3 is being installed (i.e. `jellyfin_10.4.3_linux-amd64.tar.gz`). Download the generic build, then extract the archive:
```sh
sudo wget https://github.com/jellyfin/jellyfin/releases/download/v10.4.3/jellyfin_10.4.3_linux-amd64.tar.gz
sudo tar xvzf jellyfin_10.4.3_linux-amd64.tar.gz
```
Create a symbolic link to the Jellyfin 10.4.3 directory. This allows an upgrade by repeating the above steps and enabling it by simply re-creating the symbolic link to the new version.
```sh
sudo ln -s jellyfin_10.4.3 jellyfin
```
Create four sub-directories for Jellyfin data.
```sh
sudo mkdir data cache config log
```
If you are running Debian or a derivative, you can also [download](https://repo.jellyfin.org/releases/server/debian/versions/jellyfin-ffmpeg/) and install an ffmpeg release built specifically for Jellyfin. Be sure to download the latest release that matches your OS (4.2.1-5 for Debian Stretch assumed below).
```sh
sudo wget https://repo.jellyfin.org/releases/server/debian/versions/jellyfin-ffmpeg/4.2.1-5/jellyfin-ffmpeg_4.2.1-5-stretch_amd64.deb
sudo dpkg --install jellyfin-ffmpeg_4.2.1-5-stretch_amd64.deb
```
If you run into any dependency errors, run this and it will install them and jellyfin-ffmpeg.
```sh
sudo apt install -f
```
Due to the number of command line options that must be passed, it is easiest to create a small script to run Jellyfin.
```sh
sudo nano jellyfin.sh
```
Then paste the following commands and modify as needed.
```sh
#!/bin/bash
JELLYFINDIR="/opt/jellyfin"
FFMPEGDIR="/usr/share/jellyfin-ffmpeg"
$JELLYFINDIR/jellyfin/jellyfin \
-d $JELLYFINDIR/data \
-C $JELLYFINDIR/cache \
-c $JELLYFINDIR/config \
-l $JELLYFINDIR/log \
--ffmpeg $FFMPEGDIR/ffmpeg
```
Assuming you desire Jellyfin to run as a non-root user, `chmod` all files and directories to your normal login user and group. Also make the startup script above executable.
```sh
sudo chown -R user:group *
sudo chmod u+x jellyfin.sh
```
Finally you can run it. You will see lots of log information when run, this is normal. Setup is as usual in the web browser.
```sh
./jellyfin.sh
```
### Portable DLL
Platform-agnostic .NET Core DLL builds in TAR archive format are available [here](https://jellyfin.org/downloads/#portable). These builds use the binary `jellyfin.dll` and must be loaded with `dotnet`.
### Arch Linux
Jellyfin can be found in the AUR as [`jellyfin`](https://aur.archlinux.org/packages/jellyfin/), [`jellyfin-bin`](https://aur.archlinux.org/packages/jellyfin-bin/) and [`jellyfin-git`](https://aur.archlinux.org/packages/jellyfin-git/).
### Fedora
Fedora builds in RPM package format are available [here](https://jellyfin.org/downloads/#fedora) for now but an official Fedora repository is coming soon.
1. You will need to enable rpmfusion as ffmpeg is a dependency of the jellyfin server package
```sh
sudo dnf install https://mirrors.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm https://mirrors.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm
```
:::note
You do not need to manually install ffmpeg, it will be installed by the jellyfin server package as a dependency
:::
1. Install the jellyfin server
```sh
sudo dnf install (link to version jellyfin server you want to install)
```
1. Install the jellyfin web interface
```sh
sudo dnf install (link to web RPM you want to install)
```
1. Enable jellyfin service with systemd
```sh
sudo systemctl start jellyfin
```
```sh
sudo systemctl enable jellyfin
```
1. Open jellyfin service with firewalld
```sh
sudo firewall-cmd --permanent --add-service=jellyfin
```
:::note
This will open the following ports
8096 TCP used by default for HTTP traffic, you can change this in the dashboard
8920 TCP used by default for HTTPS traffic, you can change this in the dashboard
1900 UDP used for service auto-discovery, this is not configurable
7359 UDP used for auto-discovery, this is not configurable
:::
1. Reboot your box
```sh
sudo systemctl reboot
```
1. Go to localhost:8096 or ip-address-of-jellyfin-server:8096 to finish setup in the web UI
### CentOS
CentOS/RHEL 7 builds in RPM package format are available [here](https://jellyfin.org/downloads/#centos) and an official CentOS/RHEL repository is planned for the future.
The default CentOS/RHEL repositories don't carry FFmpeg, which the RPM requires. You will need to add a third-party repository which carries FFmpeg, such as [RPM Fusion's Free repository](https://rpmfusion.org/Configuration).
You can also build [Jellyfin's version](https://github.com/jellyfin/jellyfin-ffmpeg) on your own. This includes gathering the dependencies and compiling and installing them. Instructions can be found at [the FFmpeg wiki](https://trac.ffmpeg.org/wiki/CompilationGuide/Centos).
### Debian
#### Repository
The Jellyfin team provides a Debian repository for installation on Debian Stretch/Buster. Supported architectures are `amd64`, `arm64`, and `armhf`.
:::note
Microsoft does not provide a .NET for 32-bit x86 Linux systems, and hence Jellyfin is not supported on the `i386` architecture.
:::
Steps 1 to 3 can also be replaced by:
```sh
sudo apt install extrepo
sudo extrepo enable jellyfin
```
1. Install HTTPS transport for APT as well as `gnupg` and `lsb-release` if you haven't already.
```sh
sudo apt install apt-transport-https gnupg lsb-release
```
1. Import the GPG signing key (signed by the Jellyfin Team):
```sh
wget -O - https://repo.jellyfin.org/debian/jellyfin_team.gpg.key | sudo apt-key add -
```
1. Add a repository configuration at `/etc/apt/sources.list.d/jellyfin.list`:
```sh
echo "deb [arch=$( dpkg --print-architecture )] https://repo.jellyfin.org/debian $( lsb_release -c -s ) main" | sudo tee /etc/apt/sources.list.d/jellyfin.list
```
:::note
Supported releases are `stretch`, `buster`, and `bullseye`.
:::
1. Update APT repositories:
```sh
sudo apt update
```
1. Install Jellyfin:
```sh
sudo apt install jellyfin
```
1. Manage the Jellyfin system service with your tool of choice:
```sh
sudo service jellyfin status
sudo systemctl restart jellyfin
sudo /etc/init.d/jellyfin stop
```
#### Packages
Raw Debian packages, including old versions, are available [here](https://jellyfin.org/downloads/#debian).
:::note
The repository is the preferred way to obtain Jellyfin on Debian, as it contains several dependencies as well.
:::
1. Download the desired `jellyfin` and `jellyfin-ffmpeg` `.deb` packages from the repository.
1. Install the downloaded `.deb` packages:
```sh
sudo dpkg -i jellyfin_*.deb jellyfin-ffmpeg_*.deb
```
1. Use `apt` to install any missing dependencies:
```sh
sudo apt -f install
```
1. Manage the Jellyfin system service with your tool of choice:
```sh
sudo service jellyfin status
sudo systemctl restart jellyfin
sudo /etc/init.d/jellyfin stop
```
### Ubuntu
#### Migrating to the new repository
Previous versions of Jellyfin included Ubuntu under the Debian repository. This has now been split out into its own repository to better handle the separate binary packages. If you encounter errors about the `ubuntu` release not being found and you previously configured an `ubuntu` `jellyfin.list` file, please follow these steps.
1. Remove the old `/etc/apt/sources.list.d/jellyfin.list` file:
```sh
sudo rm /etc/apt/sources.list.d/jellyfin.list
```
1. Proceed with the following section as written.
#### Ubuntu Repository
The Jellyfin team provides an Ubuntu repository for installation on Ubuntu Xenial, Bionic, Cosmic, Disco, Eoan, and Focal. Supported architectures are `amd64`, `arm64`, and `armhf`. Only `amd64` is supported on Ubuntu Xenial.
:::note
Microsoft does not provide a .NET for 32-bit x86 Linux systems, and hence Jellyfin is not supported on the `i386` architecture.
:::
1. Install HTTPS transport for APT if you haven't already:
```sh
sudo apt install apt-transport-https
```
1. Enable the Universe repository to obtain all the FFMpeg dependencies:
```sh
sudo add-apt-repository universe
```
:::note
If the above command fails you will need to install the following package `software-properties-common`.
This can be achieved with the following command `sudo apt-get install software-properties-common`
:::
1. Import the GPG signing key (signed by the Jellyfin Team):
```sh
wget -O - https://repo.jellyfin.org/ubuntu/jellyfin_team.gpg.key | sudo apt-key add -
```
1. Add a repository configuration at `/etc/apt/sources.list.d/jellyfin.list`:
```sh
echo "deb [arch=$( dpkg --print-architecture )] https://repo.jellyfin.org/ubuntu $( lsb_release -c -s ) main" | sudo tee /etc/apt/sources.list.d/jellyfin.list
```
:::note
Supported releases are `xenial`, `bionic`, `cosmic`, `disco`, `eoan`, and `focal`.
:::
1. Update APT repositories:
```sh
sudo apt update
```
1. Install Jellyfin:
```sh
sudo apt install jellyfin
```
1. Manage the Jellyfin system service with your tool of choice:
```sh
sudo service jellyfin status
sudo systemctl restart jellyfin
sudo /etc/init.d/jellyfin stop
```
#### Ubuntu Packages
Raw Ubuntu packages, including old versions, are available [here](https://jellyfin.org/downloads/#ubuntu).
:::note
The repository is the preferred way to install Jellyfin on Ubuntu, as it contains several dependencies as well.
:::
1. Enable the Universe repository to obtain all the FFMpeg dependencies, and update repositories:
```sh
sudo add-apt-repository universe
sudo apt update
```
1. Download the desired `jellyfin` and `jellyfin-ffmpeg` `.deb` packages from the repository.
1. Install the required dependencies:
```sh
sudo apt install at libsqlite3-0 libfontconfig1 libfreetype6 libssl1.0.0
```
1. Install the downloaded `.deb` packages:
```sh
sudo dpkg -i jellyfin_*.deb jellyfin-ffmpeg_*.deb
```
1. Use `apt` to install any missing dependencies:
```sh
sudo apt -f install
```
1. Manage the Jellyfin system service with your tool of choice:
```sh
sudo service jellyfin status
sudo systemctl restart jellyfin
sudo /etc/init.d/jellyfin stop
```
#### Migrating native Debuntu install to docker
It's possible to map your local installation's files to the official docker image.
:::note
You need to have exactly matching paths for your files inside the docker container! This means that if your media is stored at `/media/raid/` this path needs to be accessible at `/media/raid/` inside the docker container too - the configurations below do include examples.
:::
To guarantee proper permissions, get the `uid` and `gid` of your local jellyfin user and jellyfin group by running the following command:
```sh
id jellyfin
```
You need to replace the `<uid>:<gid>` placeholder below with the correct values.
**Using docker**
```sh
docker run -d \
--user <uid>:<gid> \
-e JELLYFIN_CACHE_DIR=/var/cache/jellyfin \
-e JELLYFIN_CONFIG_DIR=/etc/jellyfin \
-e JELLYFIN_DATA_DIR=/var/lib/jellyfin \
-e JELLYFIN_LOG_DIR=/var/log/jellyfin \
--volume </path/to/media>:</path/to/media> \
--net=host \
--restart=unless-stopped \
jellyfin/jellyfin
```
**Using docker-compose**
```yml
version: "3"
services:
jellyfin:
image: jellyfin/jellyfin
user: <uid>:<gid>
network_mode: "host"
restart: "unless-stopped"
environment:
- JELLYFIN_CACHE_DIR=/var/cache/jellyfin
- JELLYFIN_CONFIG_DIR=/etc/jellyfin
- JELLYFIN_DATA_DIR=/var/lib/jellyfin
- JELLYFIN_LOG_DIR=/var/log/jellyfin
volumes:
- /etc/jellyfin:/etc/jellyfin
- /var/cache/jellyfin:/var/cache/jellyfin
- /var/lib/jellyfin:/var/lib/jellyfin
- /var/log/jellyfin:/var/log/jellyfin
- <path-to-media>:<path-to-media>
```
## Synology
For [Synology](https://www.synology.com/en-us/dsm), Jellyfin is installed using Docker.
![Installing ynology](/images/docs/install-synology-1.png)
![Installing Synology](/images/docs/install-synology-2.png)
![Installing Synology](/images/docs/install-synology-3.png)
Create the container.
![Installing Synology](/images/docs/install-synology-4.png)
![Installing Synology](/images/docs/install-synology-5.png)
Use Advanced Settings to add mount points to your media and config.
![Installing Synology](/images/docs/install-synology-6.png)
![Installing Synology](/images/docs/install-synology-7.png)
Host Mode is required for HdHR and DLNA. Use bridge mode if running multiple instances.
![Installing Synology](/images/docs/install-synology-8.png)
![Installing Synology](/images/docs/install-synology-9.png)
Browse to `http://SERVER_IP:8096` to access the web client.

3
docs/media/_category_.json
View File

@ -1,3 +0,0 @@
{
"label": "Organizing your media"
}

43
docs/media/books.md
View File

@ -1,43 +0,0 @@
---
id: server-media-books
title: Books
---
# Books
The most common organization scheme for books is separation by Audiobook then by Author.
```txt
Books
├── Audiobooks
│ ├── Author
│ │ ├── Book1.flac
│ │ └── Book2.flac
│ └── Book
│ ├── Chapter1.flac
│ └── Chapter2.flac
└── Books
└── Author
├── Book1.epub
└── Book2.mp3
```
File extensions supported include azw, azw3, cb7, cbr, cbt, cbz, epub, mobi, and pdf.
## Primary
* folder
* poster
## Banner
* banner
## Logo
* logo
## Thumb
* thumb
* landscape

22
docs/media/internet-radio.md
View File

@ -1,22 +0,0 @@
---
id: server-media-internet-radio
title: Internet radio
---
# Internet radio
It is possible to add Internet radio stations (e.g. shoutcast) to Jellyfin by utilizing the Live TV M3U Tuner device type. Directly entering links into the M3U tuner is supported, but it depends on the provider.
If the M3U is not supported, it is most like due to missing headers in the link. Create a new M3U file containing the following data.
```#EXTM3U
#EXTINF:0,Radio Freccia
https://streamingv2.shoutcast.com/radiofreccia
```
Note that the line that starts with `#EXTINF:0,<title>` is needed for each radio URL to give it a 'channel' entry under Live TV \ Channels. Failing to add this line will cause the station to not show up under Live TV \ Channels.
Next, head over to the Jellyfin administration page, go to Live TV, add new tuner device, choose M3U Tuner as Tuner type and navigate to your M3U file. Hit Save and let Jellyfin complete the Refresh Guide task (automatically started when saving a new tuner). You should now be able to play your radio station from under Live TV \ Channels.
> [!NOTE]
> Adding an M3U HTTP link instead of a locally created M3U file will almost certainly fail, in part because the `#EXTINF:` directive is part of the IPTV standard, which is required to name the channel for Jellyfin to list it under Live TV \ Channels. Pretty much no Internet radio will include this directive in their M3U files. Besides that, many radio stations use AJAX to dynamically update the M3U-files while listening, something that is not handled by Jellyfin.

155
docs/media/movies.md
View File

@ -1,155 +0,0 @@
---
id: server-media-movies
title: Movies
---
# Movies
Movies should usually be in the library root directory or in a subfolder for the individual films. The subfolders allow for organization of metadata and images. Adding the year at the end in parentheses will yield the best results when scraping metadata.
```txt
Movies
├── Film (1990).mp4
├── Film (1994).mp4
├── Film (2008)
│   └── Film.mkv
└── Film (2010)
├── Film-cd1.avi
└── Film-cd2.avi
```
## Multiple Versions of a Movie
Multiple versions of a movie can be stored together and presented as a single title. Place each movie version in the same folder and give each version a name with the folder name as a prefix as seen below.
```txt
Movies
└── Best_Movie_Ever (2019)
├── Best_Movie_Ever (2019) - 1080P.mp4
├── Best_Movie_Ever (2019) - 720P.mp4
└── Best_Movie_Ever (2019) - Directors Cut.mp4
```
To distinguish between versions, each filename needs to have a space, hyphen, space, and then a label. Labels are not predetermined and can be made up by the user.
> [!Note]
> The hyphen is required. Periods, commas and other characters are not supported.
Additionally, labels can be placed between brackets with the same result as seen below.
```txt
Movies
└── Best_Movie_Ever (2019)
├── Best_Movie_Ever (2019) - [1080P].mp4
├── Best_Movie_Ever (2019) - [720P].mp4
└── Best_Movie_Ever (2019) - [Directors Cut].mp4
```
If labels are not added to the end of filenames, as shown above, each file will be treated as a unique movie and not a version of the same movie.
### Order of Versions
Movie versions are presented in an alphabetically sorted list. An exception applies to resolution names, which are sorted in descending order from highest to lowest resolution. A version name qualifies as a resolution name when ending with either a `p` or an `i`.
> [!Note]
> The first movie version in the list is the one selected by default.
#### Examples of Sorting
* `1080p`, `2160p`, `360p`, `480p`, `720p` → `2160p`, `1080p`, `720p`, `480p`, `360p`
* `Extended Cut`, `Cinematic Cut`, `Director's Cut` → `Cinematic Cut`, `Director's Cut`, `Extended Cut`
> [!Note]
> To group media manually, long-click or right-click media to highlight then select additional media to merge. Use the new bar that appears to 'Group Versions'.
## Movie Extras
Movie extras can include deleted scenes, interviews, and other various things that you would want to include alongside your movie. Jellyfin supports several different methods of adding these files.
### Extras Folders
One of the cleanest ways of adding extras is to place them in subfolders within your movie folder.
Supported folder types are:
* `behind the scenes`
* `deleted scenes`
* `interviews`
* `scenes`
* `samples`
* `shorts`
* `featurettes`
* `extras` - Generic catch all for extras of an unknown type.
```txt
Movies
└── Best_Movie_Ever (2019)
├── Best_Movie_Ever (2019) - 1080P.mp4
├── Best_Movie_Ever (2019) - 720P.mp4
├── Best_Movie_Ever (2019) - Directors Cut.mp4
├── behind the scenes
│ ├── Making of the Best Movie Ever.mp4
│ └── Finding the right score.mp4
├── interviews
│ └── Interview with the Director.mp4
└── extras
└── Home recreation.mp4
```
### File Name
Some types of extras support a special option if you only have a single of that type. These options are to name the filename a specific word when stored in the same folder as the movie.
Supported filenames are:
* `trailer`
* `sample`
* `theme` - Audio file of the theme song
```txt
Movies
└── Best_Movie_Ever (2019)
├── Best_Movie_Ever (2019) - 1080P.mp4
├── sample.mp4
├── theme.mp3
└── trailer.mp4
```
### File Suffix
If you would rather keep everything in a single folder, you can append special suffixes to the filename which Jellyfin picks up and uses to identify the file as an extra. Note that, with a few noted exceptions, these suffexes **DO NOT** contain any spaces.
<!-- markdownlint-disable MD038 -->
* `-trailer`
* `.trailer`
* `_trailer`
* ` trailer` - This is a space followed by the word `trailer`
* `-sample`
* `.sample`
* `_sample`
* ` sample` - This is a space followed by the word `sample`
* `-scene`
* `-clip`
* `-interview`
* `-behindthescenes`
* `-deleted`
* `-featurette`
* `-short`
<!-- markdownlint-enable MD038 -->
```txt
Movies
└── Best_Movie_Ever (2019)
├── Best_Movie_Ever (2019) - 1080P.mp4
├── That clip that I want everyone to see-clip.mp4
├── Release Trailer-trailer.mp4
├── Preview Trailer.trailer.avi
├── Release Trailer 2_trailer.avi
├── Teaser.sample.mp4
├── Favorite Scene-scene.mp4
├── The Best Ever-clip.mp4
├── Making of The Best Movie Ever-behindthescenes.mp4
├── Not the best scene-deleted.mp4
├── Theme Song Music Video-featurette.mp4
└── Art of the Best Movie Ever-short.mp4
```

94
docs/media/music.md
View File

@ -1,94 +0,0 @@
---
id: server-media-music
title: Music
---
# Music
The most common organization scheme for music is separation by artist and then album.
```txt
/Music
/Artist
/Album
01 - Song.mp3
02 - Song.mp3
```
You can also separate your music into artist folders or with no folder structure at all.
```txt
/Music
/Artist
01 - Song.flac
02 - Song.flac
08 - Song.ogg
09 - Song.ogg
```
Individual songs have no required parameters for filenames since the information will be scraped from metadata.
## Discs
Albums with several discs will be fine with the metadata tags, but you can also use subfolders for the discs. The number can be appended after a space, hyphen, or directly after one of the following keywords.
* Disc
* Disk
* CD
* Vol
* Volume
```txt
/Music
/Artist
/Album
/Disc 1
01 - Song.mp3
02 - Song.mp3
/Disc 2
01 - Song.mp3
02 - Song.mp3
```
## Images
Images will be scraped from album or artist folders, and they can also be embedded in the music files themselves. The supported filenames are listed below for each respective image.
### Primary
* folder
* poster
* cover
* default
### Art
* clearart
### Backdrop
Multiple backdrop images can be used to cycle through several over time. Simply append a number to the end of the filename directly after or after a hyphen.
* backdrop
* fanart
* background
* art
* extrafanart
### Banner
* banner
### Disc
* disc
* cdart
### Logo
* logo
### Thumb
* thumb
* landscape

87
docs/media/shows.md
View File

@ -1,87 +0,0 @@
---
id: server-media-shows
title: Shows
---
# Shows
The most common naming scheme for shows is categorizing the files by series and then season. Another common method is simply using series folders, especially for shows that are organized by air date and those without seasons. Adding the year at the end in parentheses will yield the best results when scraping metadata.
```txt
Shows
├── Series (2010)
│ ├── Season 01
│ │ ├── Episode S01E01-E02.mkv
│ │ ├── Episode S01E03.mkv
│ │ └── Episode S01E04.mkv
│ └── Season 02
│ ├── Episode S02E01.mkv
│ └── Episode S02E02.mkv
└── Series (2018)
├── Episode S01E01.mkv
├── Episode S01E02.mkv
├── Episode S02E01-E02.mkv
└── Episode S02E03.mkv
```
> [!NOTE]
> Avoid special characters such as \* in M\*A\*S\*H, use MASH instead.
> [!NOTE]
> Season folders shouldn't contain the series name, otherwise Jellyfin can in certain cases (Stargate SG-1 due to the dash and one, for instance) misdetect your episodes and put them all under the same season.
## Images
### Poster
* folder.ext
* poster.ext
* cover.ext
* default.ext
Examples:
Series (2010)/poster.jpg *for series or movie poster*
Series (2010)/Season 01/season1-poster.jpg *for season poster*
### Backdrop
* backdrop.ext
* fanart.ext
* background.ext
* art.ext
* extrafanart.ext
Examples:
Series (2010)/fanart.jpg *for the first backdrop image*
Series (2010)/extrafanart/fanart1.jpg, Series (2010)/extrafanart/fanart2.jpg, *etc for additional backdrop images*
### Banner
* banner.ext
Example:
Series (2010)/banner.jpg
### Thumb
* thumb.ext
* landscape.ext
Examples:
Series (2010)/landscape.jpg
Series (2010)/Season 01/episode filename-thumb.jpg *for the thumbnail of an episode named "episode filename.mkv"*
### Logo
* logo.ext
Example:
Series (2010)/logo.png

48
docs/media/subtitles.md
View File

@ -1,48 +0,0 @@
---
id: server-media-subtitles
title: Subtitles
---
# Subtitles
Subtitles will usually be embedded in video files, but the server also supports external subtitles. Supported formats include ass, srt, ssa, sub, idx, and vtt files.
Normally the server will only attempt to scan for local files, but if any subtitle plugins are installed there is also support for downloading remote subtitles automatically.
## Formatting
Jellyfin will search for subtitles that exactly match the video filename. They can optionally include a language code or name that will get picked up as well.
```txt
/Movies
/Film (1946)
Film.mkv
Film.vtt
Film.de.vtt
Film.german.vtt
```
## Default
Subtitles can be labeled as default by appending `.default` at the end of the filename.
```txt
/Movies
/Film (1986)
Film.mkv
Film.srt
Film.default.srt
```
### Forced
Subtitles can be set to forced by appending `.forced` or `.foreign` to the end of the file.
```txt
/Movies
/Film (2010)
Film.mkv
Film.ass
Film.forced.ass
Film.foreign.ass
```

3
docs/plugins/_category_.json
View File

@ -1,3 +0,0 @@
{
"label": "Plugins"
}

389
docs/plugins/installing-plugins.md
View File

@ -1,389 +0,0 @@
---
id: server-plugins-index
title: Installing plugins
---
Jellyfin has a collection of optional plugins that can be installed to provide additional features. To create a plugin, see the [plugin template](https://github.com/jellyfin/jellyfin-plugin-template) repository.
## Installing
### Catalog
Many plugins are available in a repository hosted on our servers, which can be easily installed using the plugin catalog in the settings. At the moment many of these are still being updated frequently so the version number may not be accurate. There are several different categories that can indicate what kind of functionality the plugins may provide.
**Note to Windows Users:**
Due to currently unresolved permission issues on Jellyfin Windows installs it is not possible to update and/or uninstall plugins from the UI.
To update and/or uninstall plugins you must stop Jellyfin, navigate to the local *plugins folder* and delete the `.dll` files for the plugins you want to update and/or uninstall.
The *plugins folder* is located in different locations depending on your install:
* `%UserProfile%\AppData\Local\jellyfin\plugins` for direct installs
* `%ProgramData%\Jellyfin\Server\plugins` for tray installs
After that start Jellyfin back up, and reinstall each plugin you want to update using the above method from the catalog.
Plugin settings should be retained if you do not delete the `.xml` files from the `<direct or tray path>\plugins\configurations` folder.
**Authentication:** Add new authentication providers, such as LDAP.
**Channels:** Allow streaming remote audio or video content.
**General:** Plugins that serve general purposes, such as sync with Trakt.tv, or Kodi.
**Live TV:** Plugins that help with connecting to tuners, such as NextPVR, or TVHeadend.
**Metadata:** Scrape metadata from a new source or modify existing metadata.
**Notifications:** Allow notifications to connect to many different services, including Gotify and Slack.
### Manual
All plugins hosted on the repository can be built from source and manually added to your server as well. They just need to be placed in the plugin directory, which is something like `/var/lib/jellyfin/plugins/` on most Linux distributions. Once the server is restarted any additions should automatically show up in your list of installed plugins. If you can't see the new plugin there may be a file permission issue.
## List
### Official Plugins
#### Metadata Plugins
Manage your Anime in Jellyfin with several different metadata providers and options for organizing your collection.
##### Anilist
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-anilist.svg)](https://github.com/jellyfin/jellyfin-plugin-anilist)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-anilist.svg)](https://github.com/jellyfin/jellyfin-plugin-anilist)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-anilist.svg)](https://github.com/jellyfin/jellyfin-plugin-anilist)
Provides metadata support from [Anilist](https://anilist.co/).
**Link:**
* [Github](https://github.com/jellyfin/jellyfin-plugin-anilist)
##### Anidb
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-anidb.svg)](https://github.com/jellyfin/jellyfin-plugin-anidb)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-anidb.svg)](https://github.com/jellyfin/jellyfin-plugin-anidb)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-anidb.svg)](https://github.com/jellyfin/jellyfin-plugin-anidb)
Provides metadata support from [Anidb](https://anidb.net/).
**Link:**
* [Github](https://github.com/jellyfin/jellyfin-plugin-anidb)
##### Anisearch
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-anisearch.svg)](https://github.com/jellyfin/jellyfin-plugin-anisearch)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-anisearch.svg)](https://github.com/jellyfin/jellyfin-plugin-anisearch)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-anisearch.svg)](https://github.com/jellyfin/jellyfin-plugin-anisearch)
Provides metadata support from [Anisearch](https://www.anisearch.com/).
**Link:**
* [Github](https://github.com/jellyfin/jellyfin-plugin-anisearch)
##### Bookshelf
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-bookshelf.svg)](https://github.com/jellyfin/jellyfin-plugin-bookshelf)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-bookshelf.svg)](https://github.com/jellyfin/jellyfin-plugin-bookshelf)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-bookshelf.svg)](https://github.com/jellyfin/jellyfin-plugin-bookshelf)
Supports several different metadata providers and options for organizing your collection.
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-bookshelf)
##### Kitsu
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-kitsu.svg)](https://github.com/jellyfin/jellyfin-plugin-kitsu)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-kitsu.svg)](https://github.com/jellyfin/jellyfin-plugin-kitsu)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-kitsu.svg)](https://github.com/jellyfin/jellyfin-plugin-kitsu)
Provides metadata support from [Kitsu](https://kitsu.io/).
* [Github](https://github.com/jellyfin/jellyfin-plugin-kitsu)
#### Auto Organize
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-autoorganize.svg)](https://github.com/jellyfin/jellyfin-plugin-autoorganize)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-autoorganize.svg)](https://github.com/jellyfin/jellyfin-plugin-autoorganize)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-autoorganize.svg)](https://github.com/jellyfin/jellyfin-plugin-autoorganize)
Automatically organizes your media by monitoring a folder and moving or copying new media files into your library folder.
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-autoorganize)
#### Email
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-emailnotifications.svg)](https://github.com/jellyfin/jellyfin-plugin-emailnotifications)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-emailnotifications.svg)](https://github.com/jellyfin/jellyfin-plugin-emailnotifications)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-emailnotifications.svg)](https://github.com/jellyfin/jellyfin-plugin-emailnotifications)
Send SMTP email notifications.
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-emailnotifications)
#### Fanart
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-fanart.svg)](https://github.com/jellyfin/jellyfin-plugin-fanart)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-fanart.svg)](https://github.com/jellyfin/jellyfin-plugin-fanart)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-fanart.svg)](https://github.com/jellyfin/jellyfin-plugin-fanart)
Scrape poster images for movies, shows, and artists in your library from [fanart.tv](https://fanart.tv).
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-fanart)
#### Kodi Sync Queue
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-kodisyncqueue.svg)](https://github.com/jellyfin/jellyfin-plugin-kodisyncqueue)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-kodisyncqueue.svg)](https://github.com/jellyfin/jellyfin-plugin-kodisyncqueue)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-kodisyncqueue.svg)](https://github.com/jellyfin/jellyfin-plugin-kodisyncqueue)
Helps keep Jellyfin for Kodi in sync with the library without needing to run periodic full scans.
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-kodisyncqueue)
#### LDAP
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-ldapauth.svg)](https://github.com/jellyfin/jellyfin-plugin-ldapauth)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-ldapauth.svg)](https://github.com/jellyfin/jellyfin-plugin-ldapauth)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-ldapauth.svg)](https://github.com/jellyfin/jellyfin-plugin-ldapauth)
Authenticate your Jellyfin users against an LDAP database, and optionally create users who do not yet exist automatically. Allows the administrator to customize most aspects of the LDAP authentication process, including customizable search attributes, username attribute, and a search filter for administrative users (set on user creation). The user, via the "Manual Login" process, can enter any valid attribute value, which will be mapped back to the specified username attribute automatically as well.
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-ldapauth)
#### NextPVR
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-nextpvr.svg)](https://github.com/jellyfin/jellyfin-plugin-nextpvr)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-nextpvr.svg)](https://github.com/jellyfin/jellyfin-plugin-nextpvr)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-nextpvr.svg)](https://github.com/jellyfin/jellyfin-plugin-nextpvr)
Provides access to Live TV, Program Guide, and Recordings from [NextPVR](https://www.nextpvr.com/).
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-nextpvr)
#### [Open Subtitles](xref:server-plugins-open-subtitles)
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-opensubtitles.svg)](https://github.com/jellyfin/jellyfin-plugin-opensubtitles)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-opensubtitles.svg)](https://github.com/jellyfin/jellyfin-plugin-opensubtitles)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-opensubtitles.svg)](https://github.com/jellyfin/jellyfin-plugin-opensubtitles)
Download subtitles from the internet to use with your media files from [Open Subtitles](https://www.opensubtitles.org/). You can configure the languages it downloads on a per-library basis.
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-opensubtitles)
#### Playback Reporting
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-playbackreporting.svg)](https://github.com/jellyfin/jellyfin-plugin-playbackreporting)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-playbackreporting.svg)](https://github.com/jellyfin/jellyfin-plugin-playbackreporting)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-playbackreporting.svg)](https://github.com/jellyfin/jellyfin-plugin-playbackreporting)
Collect and show user playback statistics, such as total time watched, media watched, time of day watched and time of week watched. Can keep information for as long as you want, or can cull older information automatically. Also allows you to manually query the data collected so you can generate your own reports.
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-playbackreporting)
#### Pushbullet
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-pushbullet.svg)](https://github.com/jellyfin/jellyfin-plugin-pushbullet)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-pushbullet.svg)](https://github.com/jellyfin/jellyfin-plugin-pushbullet)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-pushbullet.svg)](https://github.com/jellyfin/jellyfin-plugin-pushbullet)
Get notifications via Pushbullet.
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-pushbullet)
#### Reports
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-reports.svg)](https://github.com/jellyfin/jellyfin-plugin-reports)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-reports.svg)](https://github.com/jellyfin/jellyfin-plugin-reports)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-reports.svg)](https://github.com/jellyfin/jellyfin-plugin-reports)
Generate reports of your media library.
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-reports)
#### ServerWMC
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-serverwmc.svg)](https://github.com/jellyfin/jellyfin-plugin-serverwmc)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-serverwmc.svg)](https://github.com/jellyfin/jellyfin-plugin-serverwmc)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-serverwmc.svg)](https://github.com/jellyfin/jellyfin-plugin-serverwmc)
Provides access to LiveTV, Program Guide and Recordings from your Windows MediaCenter Server running ServerWMC.
Requires [ServerWMC](https://serverwmc.github.io/) to be installed and running on your Windows MediaCenter machine.
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-serverwmc)
#### Slack
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-slack.svg)](https://github.com/jellyfin/jellyfin-plugin-slack)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-slack.svg)](https://github.com/jellyfin/jellyfin-plugin-slack)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-slack.svg)](https://github.com/jellyfin/jellyfin-plugin-slack)
Get notifications via Slack.
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-slack)
#### TMDb Box Sets
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-tmdbboxsets.svg)](https://github.com/jellyfin/jellyfin-plugin-tmdbboxsets)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-tmdbboxsets.svg)](https://github.com/jellyfin/jellyfin-plugin-tmdbboxsets)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-tmdbboxsets.svg)](https://github.com/jellyfin/jellyfin-plugin-tmdbboxsets)
Automatically create movie box sets based on TMDb collections. Configerable minimum number of films to be considered a boxset. Boxsets are created as collections, and includes a schedueld task to ensure that new media is automatically put into boxsets.
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-tmdbboxsets)
#### Trakt
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-trakt.svg)](https://github.com/jellyfin/jellyfin-plugin-trakt)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-trakt.svg)](https://github.com/jellyfin/jellyfin-plugin-trakt)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-trakt.svg)](https://github.com/jellyfin/jellyfin-plugin-trakt)
Record your watched media with [Trakt](https://trakt.tv).
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-trakt)
#### TVHeadend
[![Language](https://img.shields.io/github/languages/top/jellyfin/jellyfin-plugin-tvheadend.svg)](https://github.com/jellyfin/jellyfin-plugin-tvheadend)
[![Contributors](https://img.shields.io/github/contributors/jellyfin/jellyfin-plugin-tvheadend.svg)](https://github.com/jellyfin/jellyfin-plugin-tvheadend)
[![License](https://img.shields.io/github/license/jellyfin/jellyfin-plugin-tvheadend.svg)](https://github.com/jellyfin/jellyfin-plugin-tvheadend)
Manage TVHeadEnd from Jellyfin. Click [here](xref:server-plugins-tvheadend) for plugin support.
**Links:**
* [GitHub](https://github.com/jellyfin/jellyfin-plugin-tvheadend)
### 3rd-Party Plugins
#### Antennas
Takes your tuners in TVHeadEnd and emulates a HDHomeRun, in order to connect to Jellyfin's Live TV and DVR features. It requires additional setup and configuration, but is a useful alternative to the TVHeadEnd plugin.
**Links:**
* [GitHub](https://github.com/TheJF/antennas)
#### Merge Versions
Automatically group every repeated movie.
**Links:**
* [GitHub](https://github.com/danieladov/jellyfin-plugin-mergeversions)
#### Skin Manager
Download and manage the most popular skins.
**Links:**
* [GitHub](https://github.com/danieladov/jellyfin-plugin-skin-manager)
#### Intros
Download flashy intros from prerolls.video for your movies.
**Links:**
* [GitHub](https://github.com/dkanada/jellyfin-plugin-intros)
#### YouTube Metadata
Downloads metadata of YouTube videos with a YouTube API key.
**Links:**
* [GitHub](https://github.com/ankenyr/jellyfin-youtube-metadata-plugin)
#### Last.FM
Enables audio scrobbling to Last.FM as well as a metadata fetcher source.
**Links:**
* [GitHub](https://github.com/jesseward/jellyfin-plugin-lastfm)
#### VGMdb
Adds support for VGMdb to music libraries. Can provide both images and metadata for artists and albums.
**Links:**
* [GitHub](https://github.com/nielsvanvelzen/jellyfin-plugin-vgmdb)
## Repositories
### Official Jellyfin Plugin Repositories
#### Default Repository
* Manifest
* [https://repo.jellyfin.org/releases/plugin/manifest-stable.json](https://repo.jellyfin.org/releases/plugin/manifest-stable.json)
### 3rd-Party Plugin Repositories
#### crobibero's Repo
* Manifest
* [https://repo.codyrobibero.dev/manifest.json](https://repo.codyrobibero.dev/manifest.json)
* Included Plugins
* [IMVDb](https://github.com/crobibero/jellyfin-plugin-imvdb)
* [TMDb Trailers](https://github.com/crobibero/jellyfin-plugin-tmdb-trailers)
* [Webhook](https://github.com/crobibero/jellyfin-plugin-webhook)
#### dkanada's Repo
* Manifest
* [https://dkanada.xyz/plugins/manifest.json](https://dkanada.xyz/plugins/manifest.json)
* Included Plugins
* [Intros](https://github.com/dkanada/jellyfin-plugin-intros)
#### danieladov's Repo
* Manifest
* [https://raw.githubusercontent.com/danieladov/JellyfinPluginManifest/master/manifest.json](https://raw.githubusercontent.com/danieladov/JellyfinPluginManifest/master/manifest.json)
* Included Plugins
* [Merge Versions](https://github.com/danieladov/jellyfin-plugin-mergeversions)
* [Skin Manager](https://github.com/danieladov/jellyfin-plugin-skin-manager)
* [Theme Songs](https://github.com/danieladov/jellyfin-plugin-themesongs)
#### k-matti's Repo
* Manifest
* [https://raw.githubusercontent.com/k-matti/jellyfin-plugin-repository/master/manifest.json](https://raw.githubusercontent.com/k-matti/jellyfin-plugin-repository/master/manifest.json)
* Included Plugins
* [SMS Notifications](https://github.com/k-matti/jellyfin-plugin-sms)
* [NapiSub](https://github.com/k-matti/jellyfin-plugin-napi)

8
docs/plugins/open-subtitles.md
View File

@ -1,8 +0,0 @@
---
id: server-plugins-open-subtitles
title: Open Subtitles
---
# Open Subtitles
This plugin will allow your server to download subtitles for any video files on your server from Open Subtitles. The plugin can be installed from the catalog page and once enabled you can use it with or without an account. The website doesn't require an account to download subtitles but if you'd like to enable their premium features you can add your credentials on the plugin configuration page.

73
docs/plugins/tvheadend.md
View File

@ -1,73 +0,0 @@
---
id: server-plugins-tvheadend
title: TVHeadend
---
# TVHeadend
The objective of the guide is to configure the Jellyfin TVHeadend plugin to backend a TVHeadend server.
## Requirements
* TVHeadend server
* Jellyfin server
* TVHeadend plugin installed in Jellyfin
## Configuration
<!-- markdownlint-disable MD029 ol-prefix -->
1. Create a user for Jellyfin in TVHeadend: it is convenient to create a specific user for Jellyfin.
* Go to Configuration > Users > Access Entries > Add
* Give the user parameters
* Enabled: ✔
* Username: *Username* (for example: Jellyfin)
* Change parameters: Rights,Channel number range,Channel tags,DVR configurations,Streaming profiles,Connection limits
* Web interface: ✔
* Streaming: Basic,Advanced,HTSP
* Video recoder: Basic,HTSP,View all
* (Optional) Comment: Comment for the user (for example: User used by Jellyfin)
* (Optional) Allowed networks: *Network address with network mask to allow* (for example 127.0.0.1/32)
* Press Save
* Go to Configuration > Users > Passwords > Add
* Give the user parameters
* Enabled: ✔
* Username *The user created previously* (for example: Jellyfin)
* Password: *The password for the user created previously* (for example: Jellyfin_password)
* Press Save
> [!NOTE]
> The parameters Change parameters, Streaming and Video recoder must be marked as shown. Otherwise, Jellyfin can connect to TVHeadend but problems may arise when reproducing the content.
2. Adjust the Jellyfin TVHeadend plugin to establish the connection.
* Go to Dashboard > Plugins > TVHeadend > Settings
* Provide creator access data previously:
* TVHeadend Hostname or IP Address: *IP address of the TVHeadend server* (for example: 127.0.0.1)
* Username: *The user created previously* (for example: Jellyfin)
* Password: *The password created previously* (for example: Jellyfin_password)
> [!NOTE]
> By default the the *TVHeadend Hostname or IP Address* section is configured by default with the hostname *localhost*, it is preferable to use the IP address *127.0.0.1* instead of *localhost*. [Reference](https://emby.media/community/index.php?/topic/55768-tv-headend-plugin-where-does-it-store-data/#entry542181)
3. Configure the channels for viewing in Jellyfin: even if Jellyfin manages to connect to TVHeadend, the guide will not be synchronized because there has to be a number assigned to the channels in TVHeadend. [Reference](https://emby.media/community/index.php?/topic/64583-no-channels-with-tvheadend-plugin/#entry642268)
* Manual mode
* Go to Configuration > Channel/EPG > Channels
* Select the channel to be changed and press Edit
* In the option *Number* we enter the number that we are going to assign to the channel (for example: 1), this number must be nonzero
* Press save
* Automatic mode
* Go to Configuration > DVB Inputs > Networks
* Select the network you want and press Edit
* In the option *Channel numbers from* we enter the number so we want the numbering of the channels to start (for example: 1), this number must be nonzero
* Press save
4. Update the data from the TVHeadend guide to Jellyfin
* Go to Dashboard > Live TV
* Refresh guide data
<!-- markdownlint-enable MD029 ol-prefix -->
> [!NOTE]
> If the guide is not updated, restart the Jellyfin server.
Once the update of the guide is finished, the Live TV will already be able to see the guide related to the synchronized channels and will be able to visualize the content.

3
docs/reverse-proxy/_category_.json
View File

@ -1,3 +0,0 @@
{
"label": "Using with a reverse proxy"
}

63
docs/reverse-proxy/apache.md
View File

@ -1,63 +0,0 @@
---
id: network-reverse-proxy-apache
title: Apache
---
## Apache HTTP Server Project
"The [Apache HTTP Server Project](https://httpd.apache.org/) is an effort to develop and maintain an open-source HTTP server for modern operating systems including UNIX and Windows. The goal of this project is to provide a secure, efficient and extensible server that provides HTTP services in sync with the current HTTP standards."
```conf
<VirtualHost *:80>
ServerName DOMAIN_NAME
# Comment to prevent HTTP to HTTPS redirect
Redirect permanent / https://DOMAIN_NAME
ErrorLog /var/log/apache2/DOMAIN_NAME-error.log
CustomLog /var/log/apache2/DOMAIN_NAME-access.log combined
</VirtualHost>
# If you are not using a SSL certificate, replace the 'redirect'
# line above with all lines below starting with 'Proxy'
<IfModule mod_ssl.c>
<VirtualHost *:443>
ServerName DOMAIN_NAME
# This folder exists just for certbot(You may have to create it, chown and chmod it to give apache permission to read it)
DocumentRoot /var/www/html/jellyfin/public_html
ProxyPreserveHost On
# Letsencrypt's certbot will place a file in this folder when updating/verifying certs
# This line will tell apache to not to use the proxy for this folder.
ProxyPass "/.well-known/" "!"
ProxyPass "/socket" "ws://SERVER_IP_ADDRESS:8096/socket"
ProxyPassReverse "/socket" "ws://SERVER_IP_ADDRESS:8096/socket"
ProxyPass "/" "http://SERVER_IP_ADDRESS:8096/"
ProxyPassReverse "/" "http://SERVER_IP_ADDRESS:8096/"
SSLEngine on
SSLCertificateFile /etc/letsencrypt/live/DOMAIN_NAME/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/DOMAIN_NAME/privkey.pem
Protocols h2 http/1.1
# Enable only strong encryption ciphers and prefer versions with Forward Secrecy
SSLCipherSuite HIGH:RC4-SHA:AES128-SHA:!aNULL:!MD5
SSLHonorCipherOrder on
# Disable insecure SSL and TLS versions
SSLProtocol all -SSLv2 -SSLv3 -TLSv1 -TLSv1.1
ErrorLog /var/log/apache2/DOMAIN_NAME-error.log
CustomLog /var/log/apache2/DOMAIN_NAME-access.log combined
</VirtualHost>
</IfModule>
```
If you encouter errors, you may have to enable `mod_proxy`, `mod_ssl`, `proxy_wstunnel` and `remoteip` support manually.
```bash
sudo a2enmod proxy proxy_http ssl proxy_wstunnel remoteip
```

80
docs/reverse-proxy/caddy.md
View File

@ -1,80 +0,0 @@
---
id: network-reverse-proxy-caddy
title: Caddy
---
# Caddy
"[Caddy](https://caddyserver.com/), sometimes clarified as the Caddy web server, is an open source, HTTP/2-enabled web server written in Go. It uses the Go standard library for its HTTP functionality." - [Wikipedia](https://en.wikipedia.org/wiki/Caddy_(web_server))
You can reverse proxy to Jellyfin either with or without a config file, and either method offers automatic HTTPS if you want to use your public domain name.
**If you want HTTPS, make sure your domain name's A/AAAA records are pointed at your public IP address.**
If you aren't familiar with Caddy yet, check out its [Getting Started](https://caddyserver.com/docs/getting-started) guide.
## One-liners
The easiest way to reverse proxy to Jellyfin is with the `reverse-proxy` command:
```bash
caddy reverse-proxy --from :5001 --to 127.0.0.1:8096
```
That is a simple but production-ready plaintext HTTP reverse proxy.
If you have:
- permission to bind to low ports, and
- a public domain name's DNS records pointed at your machine,
then you can serve over HTTPS just as easily:
```bash
caddy reverse-proxy --from example.com --to 127.0.0.1:8096
```
You will see Caddy provision a TLS certificate for your site and if it succeeds, you can then access your Jellyfin server over HTTPS with your domain name.
## Caddyfile
If you want to use a config file, create a file called `Caddyfile` for the configuration.
The first `reverse-proxy` command above is equivalent to the following options.
```txt
:5001
reverse_proxy 127.0.0.1:8096
```
To get HTTPS, simply change the first line to your domain name.
```txt
example.com
reverse_proxy 127.0.0.1:8096
```
### Subpath
You can serve Jellyfin only at a particular base path and not proxy all other requests.
To do this, first configure Jellyfin to use a base path.
Go to `Admin > Networking` and in the Base URL field, enter a path like `/jellyfin`.
You might have to restart the Jellyfin server for this to take effect.
Then simply give the `reverse_proxy` directive a path matcher.
```txt
example.com
reverse_proxy /jellyfin/* 127.0.0.1:8096
```
With that config, Caddy will only proxy requests that start with `/jellyfin/`.
Note the trailing slash - that is optional, but recommended.
## Community Links
- [Windows plus DuckDNS Setup](https://forum.jellyfin.org/t/securing-your-jellyfin-install-https-with-caddy-server/282)
- [Windows Guide for Caddy v2](https://www.reddit.com/r/jellyfin/comments/gdwe0s/windows_and_caddy_v2_reverse_proxy_guide)
- [Windows Guide for Caddy v1](https://www.reddit.com/r/jellyfin/comments/ek8ugr/windows_reverse_proxy_guide)

40
docs/reverse-proxy/haproxy.md
View File

@ -1,40 +0,0 @@
---
id: network-reverse-proxy-haproxy
title: HAProxy
---
## HAProxy
"[Haproxy](https://www.haproxy.com/) is a free, open source software that provides a high availability load balancer and proxy server for TCP and HTTP-based applications that spreads requests across multiple servers.[1] It is written in C[2] and has a reputation for being fast and efficient (in terms of processor and memory usage)." - [Wikipedia](https://en.wikipedia.org/wiki/HAProxy)
```txt
frontend jellyfin_proxy
bind *:80
# Note that haproxy requires you to concatenate the certificate and key into a single file
# Uncomment the appropriate lines after you have acquired a SSL Certificate
#
# HAProxy <1.7
# bind *:443 ssl crt /etc/ssl/DOMAIN_NAME.pem
#
# HAProxy >1.8
# bind *:443 ssl crt /etc/ssl/DOMAIN_NAME.pem alpn h2,http/1.1
# redirect scheme https if !{ ssl_fc }
#
# Uncomment these lines to allow LetsEncrypt authentication
# acl letsencrypt_auth path_beg /.well-known/acme-challenge/
# use_backend letsencrypt if letsencrypt_auth
acl jellyfin_server hdr(host) -i DOMAIN_NAME
use_backend jellyfin if jellyfin_server
backend jellyfin
http-request set-header X-Forwarded-Port %[dst_port]
http-request add-header X-Forwarded-Proto https if { ssl_fc }
server jellyfin SERVER_IP_ADDRESS:8096
# Uncomment these lines to allow LetsEncrypt authentication
#
#backend letsencrypt
# server letsencrypt 127.0.0.1:8888
```

249
docs/reverse-proxy/nginx.md
View File

@ -1,249 +0,0 @@
---
id: network-reverse-proxy-nginx
title: Nginx
---
## Nginx
"[Nginx](https://www.nginx.com/) (pronounced "engine X") is a web server which can also be used as a reverse proxy, load balancer, mail proxy and HTTP cache. The software was created by Igor Sysoev and first publicly released in 2004.[9] A company of the same name was founded in 2011 to provide support and Nginx plus paid software." - [Wikipedia](https://en.wikipedia.org/wiki/Nginx)
## Nginx from a subdomain (jellyfin.example.org)
> [!WARNING]
> HTTP is insecure. The following configuration is provided for ease of use only. If you are planning on exposing your server over the Internet you should setup HTTPS. [Let's Encrypt](https://letsencrypt.org/getting-started/) can provide free TLS certificates which can be installed easily via [certbot](https://certbot.eff.org/). Using only HTTP will expose passwords and API keys.
Create the file `/etc/nginx/conf.d/jellyfin.conf` which will forward requests to Jellyfin.
```config
# Uncomment the commented sections after you have acquired a SSL Certificate
server {
listen 80;
listen [::]:80;
# server_name DOMAIN_NAME;
# Uncomment to redirect HTTP to HTTPS
# return 301 https://$host$request_uri;
#}
#server {
# listen 443 ssl http2;
# listen [::]:443 ssl http2;
server_name DOMAIN_NAME;
# use a variable to store the upstream proxy
# in this example we are using a hostname which is resolved via DNS
# (if you aren't using DNS remove the resolver line and change the variable to point to an IP address e.g `set $jellyfin 127.0.0.1`)
set $jellyfin jellyfin;
resolver 127.0.0.1 valid=30;
#ssl_certificate /etc/letsencrypt/live/DOMAIN_NAME/fullchain.pem;
#ssl_certificate_key /etc/letsencrypt/live/DOMAIN_NAME/privkey.pem;
#include /etc/letsencrypt/options-ssl-nginx.conf;
#ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
#add_header Strict-Transport-Security "max-age=31536000" always;
#ssl_trusted_certificate /etc/letsencrypt/live/DOMAIN_NAME/chain.pem;
#ssl_stapling on;
#ssl_stapling_verify on;
# 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";
# Content Security Policy
# See: https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP
# Enforces https content and restricts JS/CSS to origin
# External Javascript (such as cast_sender.js for Chromecast) must be whitelisted.
#add_header Content-Security-Policy "default-src https: data: blob: http://image.tmdb.org; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline' https://www.gstatic.com/cv/js/sender/v1/cast_sender.js https://www.youtube.com blob:; worker-src 'self' blob:; connect-src 'self'; object-src 'none'; frame-ancestors 'self'";
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;
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;
}
}
```
## Nginx with Subpath (example.org/jellyfin)
When connecting to server from a client application, enter `http(s)://DOMAIN_NAME/jellyfin` in the address field.
Set the [base URL](xref:network-index#base-url) field in the Jellyfin server. This can be done by navigating to the Admin Dashboard -> Networking -> Base URL in the web client. Fill in this box with `/jellyfin` and click Save. The server will need to be restarted before this change takes effect.
> [!WARNING]
> HTTP is insecure. The following configuration is provided for ease of use only. If you are planning on exposing your server over the Internet you should setup HTTPS. [Let's Encrypt](https://letsencrypt.org/getting-started/) can provide free TLS certificates which can be installed easily via [certbot](https://certbot.eff.org/).
```conf
# Jellyfin hosted on http(s)://DOMAIN_NAME/jellyfin
server {
listen 80;
listen [::]:80;
server_name DOMAIN_NAME;
# You can specify multiple domain names if you want
#server_name jellyfin.local;
# use a variable to store the upstream proxy
# in this example we are using a hostname which is resolved via DNS
# (if you aren't using DNS remove the resolver line and change the variable to point to an IP address e.g `set $jellyfin 127.0.0.1`)
set $jellyfin jellyfin;
resolver 127.0.0.1 valid=30;
# Uncomment and create directory to also host static content
#root /srv/http/media;
index index.html;
location / {
try_files $uri $uri/ =404;
}
# Jellyfin
location /jellyfin {
return 302 $scheme://$host/jellyfin/;
}
location /jellyfin/ {
# Proxy main Jellyfin traffic
# The / at the end is significant.
# https://www.acunetix.com/blog/articles/a-fresh-look-on-reverse-proxy-related-attacks/
proxy_pass http://$jellyfin:8096/jellyfin/;
proxy_pass_request_headers on;
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-Host $http_host;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection $http_connection;
# Disable buffering when the nginx proxy gets very resource heavy upon streaming
proxy_buffering off;
}
}
```
## Extra Nginx Configurations
### Cache Video Streams
```conf
#Must be in HTTP block
proxy_cache_path /home/cache/web levels=1:2 keys_zone=cWEB:50m inactive=90d max_size=35000m;
map $request_uri $h264Level { ~(h264-level=)(.+?)& $2; }
map $request_uri $h264Profile { ~(h264-profile=)(.+?)& $2; }
#set in Server block
proxy_cache cWEB;
proxy_cache_valid 200 301 302 30d;
proxy_ignore_headers Expires Cache-Control Set-Cookie X-Accel-Expires;
proxy_cache_use_stale error timeout invalid_header updating http_500 http_502 http_503 http_504;
proxy_connect_timeout 10s;
proxy_http_version 1.1;
proxy_set_header Connection "";
location /videos/
{
proxy_pass http://myJF-IP:8096;
proxy_cache_key "mydomain.com$uri?MediaSourceId=$arg_MediaSourceId&VideoCodec=$arg_VideoCodec&AudioCodec=$arg_AudioCodec&AudioStreamIndex=$arg_AudioStreamIndex&VideoBitrate=$arg_VideoBitrate&AudioBitrate=$arg_AudioBitrate&SubtitleMethod=$arg_SubtitleMethod&TranscodingMaxAudioChannels=$arg_TranscodingMaxAudioChannels&RequireAvc=$arg_RequireAvc&SegmentContainer=$arg_SegmentContainer&MinSegments=$arg_MinSegments&BreakOnNonKeyFrames=$arg_BreakOnNonKeyFrames&h264-profile=$h264Profile&h264-level=$h264Level";
proxy_cache_valid 200 301 302 30d;
}
```
### Cache Images
```conf
# Add this outside of you server block (i.e. http block)
proxy_cache_path /var/cache/nginx/jellyfin levels=1:2 keys_zone=jellyfin:100m max_size=15g inactive=30d use_temp_path=off;
# Cache images (inside server block)
location ~ /Items/(.*)/Images {
proxy_pass http://127.0.0.1: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;
proxy_cache jellyfin;
proxy_cache_revalidate on;
proxy_cache_lock on;
# add_header X-Cache-Status $upstream_cache_status; # This is only to check if cache is working
}
```
Ensure that the directory /var/cache/nginx/jellyfin exists and the nginx user has write permissions on it! All the cache options used are explained on [Nginx blog](https://www.nginx.com/blog/nginx-caching-guide/) and [Nginx proxy module](http://nginx.org/en/docs/http/ngx_http_proxy_module.html).
### Rate Limit Downloads
```conf
# Add this outside of you server block (i.e. http block)
limit_conn_zone $binary_remote_addr zone=addr:10m;
# Downloads limit (inside server block)
location ~ /Items/(.*)/Download$ {
proxy_pass http://127.0.0.1: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;
limit_rate 1700k; # Speed limit (here is on kb/s)
limit_conn addr 3; # Number of simultaneous downloads per IP
limit_conn_status 460; # Custom error handling
# proxy_buffering on; # Be sure buffering is on (it is by default on nginx), otherwise limits won't work
}
# Error page
error_page 460 http://your-page-telling-your-limit/;
```
[See here for more](https://www.nginx.com/blog/rate-limiting-nginx/)

180
docs/reverse-proxy/traefik.md
View File

@ -1,180 +0,0 @@
---
id: network-reverse-proxy-traefik
title: Traefik v1.x
---
## Traefik v1.x
[Traefik](https://traefik.io/) is a modern HTTP reverse proxy and load balancer that makes deploying microservices easy. Traefik integrates with your existing infrastructure components (Docker, Swarm mode, Kubernetes, Marathon, Consul, Etcd, Rancher, Amazon ECS, ...) and configures itself automatically and dynamically. Pointing Traefik at your orchestrator should be the only configuration step you need. This configuration is A+. Test your setup here at [SSLlabs](https://www.ssllabs.com/ssltest/).
Create docker-compose.yml, traefik.toml and acme.json in the **same** directory or change their paths in the volume section.
> [!NOTE]
> Ensure you enable Basic Auth protection for Traefik or disable its Dashboard. Otherwise your Dashboard will be accessible from the internet.
```bash
sudo apt install apache2-utils
echo $(htpasswd -nb username mystrongpassword) | sed -e s/\\$/\\$\\$/g
```
This command automatically escapes all $ inside the password for the YML file. If using an environment file, it does not need the $ escaped since it will not be interpreted by the shell.
Create the docker network for traefik.
```bash
sudo docker network create traefik
```
### docker-compose.yml
```yml
version: '3.5'
networks:
traefik:
name: traefik
services:
traefik:
container_name: traefik
image: traefik:v1.7
networks:
- traefik
ports:
- 80:80
- 443:443
volumes:
- /var/run/docker.sock:/var/run/docker.sock
- ./traefik.toml:/traefik.toml
- ./acme.json:/acme.json
labels:
traefik.enable: "true"
traefik.backend: traefik
traefik.docker.network: traefik
traefik.port: 8080
traefik.frontend.rule: Host:traefik.example.com,
traefik.frontend.entryPoints: https
traefik.frontend.passHostHeader: "true"
traefik.frontend.headers.SSLForceHost: "true"
traefik.frontend.headers.SSLHost: traefik.example.com
traefik.frontend.headers.SSLRedirect: "true"
traefik.frontend.headers.browserXSSFilter: "true"
traefik.frontend.headers.contentTypeNosniff: "true"
traefik.frontend.headers.forceSTSHeader: "true"
traefik.frontend.headers.STSSeconds: 315360000
traefik.frontend.headers.STSIncludeSubdomains: "true"
traefik.frontend.headers.STSPreload: "true"
traefik.frontend.headers.customResponseHeaders: X-Robots-Tag:noindex,nofollow,nosnippet,noarchive,notranslate,noimageindex
traefik.frontend.headers.frameDeny: "true"
traefik.frontend.headers.customFrameOptionsValue: 'allow-from https://example.com'
# traefik.frontend.auth.basic.users: xxx:xxx
restart: unless-stopped
jellyfin:
image: jellyfin/jellyfin
container_name: jellyfin
network_mode: "host"
volumes:
- /path/to/config:/config
- /path/to/cache:/cache
- /path/to/media:/media
restart: unless-stopped
```
This TOML file can't support environment variables, so don't attempt to use variables.
> [!WARNING]
> Due to a [bug](https://github.com/containous/traefik/issues/5559) in Traefik, you cannot dynamically route to containers when network_mode=host, so we have created a static route to the docker host (172.17.0.1:8096) in `traefik.toml`. Using host networking (or macvlan) is required to use DLNA or an HdHomeRun as it supports multicast networking.
### traefik.toml
```toml
logLevel = "WARN"
defaultEntryPoints = ["http", "https"]
[entryPoints]
[entryPoints.http]
address = ":80"
[entryPoints.http.redirect]
entryPoint = "https"
[entryPoints.https]
address = ":443"
[entryPoints.https.tls]
minVersion = "VersionTLS12"
cipherSuites = [
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305",
"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305",
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
]
[retry]
[api]
[acme]
acmeLogging = true
email = "user@example.com"
storage = "acme.json"
entryPoint = "https"
[acme.dnsChallenge]
provider = "provider"
delayBeforeCheck = "60"
[[acme.domains]]
main = "*.example.com"
[docker]
domain = "example.com"
network = "traefik"
exposedbydefault = false
[file]
[backends]
[backends.backend-jellyfin]
[backends.backend-jellyfin.servers]
[backends.backend-jellyfin.servers.server-1]
url = "http://172.17.0.1:8096"
[frontends]
[frontends.jellyfin]
backend = "backend-jellyfin"
passHostHeader = true
[frontends.jellyfin.routes]
[frontends.jellyfin.routes.route-jellyfin-ext]
rule = "Host:jellyfin.example.com"
[frontends.jellyfin.headers]
SSLRedirect = true
SSLHost = "jellyfin.example.com"
SSLForceHost = true
STSSeconds = 315360000
STSIncludeSubdomains = true
STSPreload = true
forceSTSHeader = true
frameDeny = true
contentTypeNosniff = true
browserXSSFilter = true
customResponseHeaders = "X-Robots-Tag:noindex,nofollow,nosnippet,noarchive,notranslate,noimageindex"
customFrameOptionsValue = "allow-from https://example.com"
```
Finally, create an empty acme.json file to handle the certificate.
```bash
touch acme.json
chmod 600 acme.json
```
> [!WARNING]
> Change example.com to your domain name and update the acme.json file with your email address. Let's Encrypt does not require a valid email but example.com will be flagged as fake.
Launch the Traefik and Jellyfin services.
```bash
docker-compose up -d
```
Congratulations, your stack with Traefik and Jellyfin is running!
Go to the domain you used earlier in the config file and your Jellyfin server will be running with HTTPS (AES 256) enabled.

283
docs/reverse-proxy/traefik2.md
View File

@ -1,283 +0,0 @@
---
id: network-reverse-proxy-traefik2
title: Traefik v2.x
---
## Traefik v2.x
[Traefik](https://traefik.io/) is a modern HTTP reverse proxy and load balancer that makes deploying microservices easy. Traefik integrates with your existing infrastructure components (ie: Docker) and generally configures itself dynamically as services are added or removed.
This document provides a complete configuration of Traefik v2.x and Jellyfin. It uses a number of files including a `docker-compose.yml` file, `traefik.toml` (your Traefik static configuration), `traefik-provider.toml` (a file-based provider for Traefik), `traefik.log` (an optional log file), `.env` (the environment which may be needed for your ACME/LetsEncrypt providers), and `acme.json` (the state data for your ACME/LetsEncrypt certificate). The files should all be created in the **same** directory. Alternately, alter the paths in the volume section of the `traefik` service in `docker-compose.yml`. You can optionally jam some of the traefik.toml file into labels for the traefik service in `docker-compose.yml`, however this method is much clearer and easier to comment.
> [!NOTE]
> Ensure you enable some basic firewall or auth protection for Traefik or disable its dashboard. If you do not, your dashboard may be accessible from the internet. Pay attention to accessibility via IPv6, as even systems on an internal home network may be directly accessible over IPv6. See [api-insecure](https://docs.traefik.io/operations/api/#insecure) for more details on securing the dashboard.
> [!NOTE]
> Traefik has many options for the configuration of LetsEncrypt using your choice of challenges. If your server is accessible from the Internet via port 80 or 443, you can use the HTTP-01 or TLS-ALPN-01 challenges. If so, the certificatesresolvers.leresolver.acme.httpchallenge.entrypoint must be reachable by Let's Encrypt through port 80/443. You can also use a DNS-01 challenge via one of the available [providers](https://docs.traefik.io/https/acme/#providers). Configuration is beyond the scope of this guide. This guide can use both HTTP-01 and DNS-01 by commenting or uncommenting the various blocks. You are most likely to use HTTP-01 unless you have full access to your DNS configuration. The configuration below uses RFC2136 (as set by certificatesresolvers.leresolver.acme.dnsChallenge of `traefik.toml`) and the variables for that provider are shown in the `.env` file as a formatting guide. See provider documentation and comments about configuration of your ACME provider of choice, or change the configuration to HTTP-01 in `traefik.toml`'s comments.
The configuration below creates a Traefik v2.x installation with access at entryPoint ports 80 (labelled 'http'), 443 (labeled 'https'), and 9999 (labeled 'secure'). Unrelated to this Jellyfin configuration, it redirects all traffic from http (port 80) to https (port 443) to ensure all data is encrypted. As for Jellyfin, it makes the service accessible without a path on the secure entry point. This configuration is intended to be used as a starting point and some adaptation is likely required for your configuration. If you want Jellyfin to be accessible without using a port (using the default https port), simply change 'secure' to 'https' in `docker-compose.yml` where indicated and remove the ':9999' from the SSLHost parameter. If you want Jellyfin to be accessible with a path, simply add the PathPrefix (i.e. '/jellyfin') and see the note near the end of this document about configuring Jellyfin.
### docker-compose.yml
```yml
version: '2.4'
services:
traefik:
container_name: traefik
image: traefik:chevrotin # the chevrotin tag refers to v2.2.x
restart: unless-stopped
volumes:
# So that Traefik can listen to the Docker events (read-only)
- /var/run/docker.sock:/var/run/docker.sock:ro
# TOML Configuration with global options
- /srv/traefik.toml:/traefik.toml
# Configuration for the file provider (needed for host networking and default TLS Options)
- /srv/traefik-provider.toml:/traefik-provider.toml
# LetsEncrypt ACME Configuration
- /srv/acme.json:/acme.json
# Log File (optional)
- /srv/traefik.log:/traefik.log
ports:
# The Web UI (enabled by --api.insecure=true in traefik.toml)
- 8080:8080
# The Available Ports (forward your router's incoming ports to the ports on the host)
- 80:80
- 443:443
- 9999:9999
env_file: .env
jellyfin:
image: jellyfin/jellyfin
container_name: "jellyfin"
user: 1000:1000
group_add: # by id as these may not exist within the container. Needed to provide permissions to the VAAPI Devices
- "107" #render
- "44" #video
# Network mode of 'host' exposes the ports on the host. This is needed for DLNA access.
network_mode: "host"
volumes:
- /path/to/config:/config
- /path/to/cache:/cache
# Update this configuration as desired
- /path/to/media:/media
restart: always
devices:
# VAAPI Devices
- /dev/dri/renderD128:/dev/dri/renderD128
- /dev/dri/card0:/dev/dri/card0
labels:
- "traefik.enable=true"
## HTTP Router
#### Entry point where Jellyfin is accessible via
#### Change secure to https in the line below to have accessible without needing to specify a port and change the SSLHost option below
- "traefik.http.routers.jellyfin.entryPoints=secure"
#### Host or Path where Jellyfin is accessible
#### Remove (or change) this rule if you'd rather have Jellyfin accessible at a PathPrefix URI
- "traefik.http.routers.jellyfin.rule=Host(`HOST_NAME.DOMAIN_NAME`)" # OPTIONAL: && PathPrefix(`/jellyfin`)
#### Enable TLS with the ACME/LetsEncrypt resolver for HOSTNAME.DOMAIN_NAME
- "traefik.http.routers.jellyfin.tls=true"
- "traefik.http.routers.jellyfin.tls.certResolver=leresolver"
- "traefik.http.routers.jellyfin.tls.domains=HOSTNAME.DOMAIN_NAME"
## Middleware
- "traefik.http.routers.jellyfin.middlewares=jellyfin-mw"
#### The customResponseHeaders option lists the Header names and values to apply to the response.
- "traefik.http.middlewares.jellyfin-mw.headers.customResponseHeaders.X-Robots-Tag=noindex,nofollow,nosnippet,noarchive,notranslate,noimageindex"
#### The sslRedirect is set to true, then only allow https requests.
- "traefik.http.middlewares.jellyfin-mw.headers.SSLRedirect=true"
#### The sslHost option is the host name that is used to redirect http requests to https.
#### This is the exact URL that will be redirected to, so you can remove the :9999 port if using default SSL port
- "traefik.http.middlewares.jellyfin-mw.headers.SSLHost=HOST_NAME.DOMAIN_NAME:9999"
#### Set sslForceHost to true and set SSLHost to forced requests to use SSLHost even the ones that are already using SSL.
#### Note that this uses SSLHost verbatim, so add the port to SSLHost if you are using an alternate port.
- "traefik.http.middlewares.jellyfin-mw.headers.SSLForceHost=true"
#### The stsSeconds is the max-age of the Strict-Transport-Security header. If set to 0, would NOT include the header.
- "traefik.http.middlewares.jellyfin-mw.headers.STSSeconds=315360000"
#### The stsIncludeSubdomains is set to true, the includeSubDomains directive will be
#### appended to the Strict-Transport-Security header.
- "traefik.http.middlewares.jellyfin-mw.headers.STSIncludeSubdomains=true"
#### Set stsPreload to true to have the preload flag appended to the Strict-Transport-Security header.
- "traefik.http.middlewares.jellyfin-mw.headers.STSPreload=true"
#### Set forceSTSHeader to true, to add the STS header even when the connection is HTTP.
- "traefik.http.middlewares.jellyfin-mw.headers.forceSTSHeader=true"
#### Set frameDeny to true to add the X-Frame-Options header with the value of DENY.
- "traefik.http.middlewares.jellyfin-mw.headers.frameDeny=true"
#### Set contentTypeNosniff to true to add the X-Content-Type-Options header with the value nosniff.
- "traefik.http.middlewares.jellyfin-mw.headers.contentTypeNosniff=true"
#### Set browserXssFilter to true to add the X-XSS-Protection header with the value 1; mode=block.
- "traefik.http.middlewares.jellyfin-mw.headers.browserXSSFilter=true"
#### The customFrameOptionsValue allows the X-Frame-Options header value to be set with a custom value. This
#### overrides the FrameDeny option.
- "traefik.http.middlewares.jellyfin-mw.headers.customFrameOptionsValue='allow-from https://DOMAIN_NAME'"
## HTTP Service
# We define the port here as a port is required, but note that the service is pointing to the service defined in @file
- "traefik.http.routers.jellyfin.service=jellyfin-svc@file"
- "traefik.http.services.jellyfin-svc.loadBalancer.server.port=8096"
- "traefik.http.services.jellyfin-svc.loadBalancer.passHostHeader=true"
## Redirection of HTTP on port 9999 to HTTPS on port 9999 (consistent protocol)
- "traefik.http.routers.jellyfin-insecure.entryPoints=secure"
- "traefik.http.routers.jellyfin-insecure.rule=Host(`HOST_NAME.DOMAIN_NAME`)" # OPTIONAL: && PathPrefix(`/jellyfin`)
- "traefik.http.routers.jellyfin-insecure.middlewares=jellyfin-insecure-mw"
- "traefik.http.middlewares.jellyfin-insecure-mw.redirectscheme.scheme=https"
- "traefik.http.middlewares.jellyfin-insecure-mw.redirectscheme.port=9999" # remove if you are using a default port
- "traefik.http.middlewares.jellyfin-insecure-mw.redirectscheme.permanent=false"
- "traefik.http.routers.jellyfin-insecure.service=noop@internal"
```
> [!WARNING]
> TOML files can't support environment variables, so all values must be hard coded.
### traefik.toml
```toml
[log]
# By default, the level is set to ERROR. Alternative logging levels
# are DEBUG, PANIC, FATAL, ERROR, WARN, and INFO.
level = "DEBUG"
filePath = "/traefik.log"
[docker]
# Defines a default docker network to use for connections to all
# containers. This option can be overridden on a container basis
# with the traefik.docker.network label.
network = "traefik"
# Expose containers by default through Traefik. If set to false,
# containers that don't have a traefik.enable=true label will be
# ignored from the resulting routing configuration.
exposedbydefault = false
[api]
# Enable the API in insecure mode, which means that the API will be
# available directly on the entryPoint named traefik. If the entryPoint
# named traefik is not configured, it will be automatically created on
# port 8080.
insecure = true
[providers]
# Connection to docker host system (docker.sock)
# Attach labels to your containers and let Traefik do the rest!
# Traefik works with both Docker (standalone) Engine and Docker Swarm Mode.
# See: https://docs.traefik.io/providers/docker/
[providers.docker]
# Traefik requires access to the docker socket to get its dynamic
# configuration.
endpoint = "unix:///var/run/docker.sock"
[providers.file]
filename = "/traefik-provider.toml"
# EntryPoints are the network entry points into Traefik. They define
# the port which will receive the packets, and whether to listen for
# TCP or UDP.
# See: https://docs.traefik.io/routing/entrypoints/
# NOTE: If a TLS section (i.e. any of its fields) is defined in your docker-compose.yml file,
# then the default configuration does not apply at all.
[entryPoints]
# Standard HTTP redirects to HTTPS
[entryPoints.http]
address = ":80"
[entryPoints.http.http]
[entryPoints.http.http.redirections]
[entryPoints.http.http.redirections.entrypoint]
to = "https"
scheme = "https"
# Standard HTTPS
[entryPoints.https]
address = ":443"
[entryPoints.https.http.tls]
certResolver = "leresolver"
[[entryPoints.https.http.tls.domains]]
main = "HOST_NAME.DOMAIN_NAME"
# SANS are any other hostnames which Traefik should obtain a certificate for.
# If you are using DNS for LetsEncrypt, you can set a wildcard.
# Include all possible hostnames of this server.
#sans = ["*.DOMAIN_NAME"]
# Alternate HTTPS Port (for services - accepts both HTTP and HTTP by not defining a TLS configuration here)
[entryPoints.secure]
address = ":9999"
# Enable ACME (Let's Encrypt): automatic SSL.
[certificatesresolvers.leresolver.acme]
email = "YOU@DOMAIN_NAME"
storage = "acme.json"
# Use HTTP-01 ACME challenge
#[certificateresolvers.leresolver.acme.httpChallenge]
# entryPoint = "http"
# Use a DNS-01 ACME challenge rather than HTTP-01 challenge.
# Mandatory for wildcard certificate generation.
[certificatesresolvers.leresolver.acme.dnsChallenge]
# Update this to your provider of choice and then ensure necessary variables are in the .env file to support it.
provider = "rfc2136"
delayBeforeCheck = 0
# A DNS server used to check whether the DNS is set up correctly before
# making the ACME request. Ideally a DNS server that isn't going to cache an old entry.
resolvers = ["8.8.8.8:53"]
[retry]
```
Due to a [quirk](https://github.com/containous/traefik/issues/5559) in Traefik, you cannot dynamically route to containers when network_mode=host. We have created a static route to the docker host (192.168.1.xx:8096) in `traefik-provider.toml`. The use of host networking (as in this doc) or macvlan are required to use DLNA or an HdHomeRun so it can utilize the multicast network. `traefik-provider.toml` defines the jellyfin-svc@file service which we are pointing the router to in the `docker-compose.yml` file. You can not set a URL in `docker-compose.yml` which is why we set up this service externally. Be sure to update the IP address below to the IP address of the host on the local network (in this case, 192.168.1.xx).
### traefik-provider.toml
```toml
[http]
[http.services]
[http.services.jellyfin-svc]
[[http.services.jellyfin-svc.loadBalancer.servers]]
url = "http://192.168.1.xx:8096"
# Set secure options by disabling insecure older TLS/SSL versions
# and insecure ciphers. SNIStrict disabled leaves TLS1.0 open.
# If you have problems with older clients, you can may need to relax
# these minimums. This configuration will give you an A+ SSL security
# score supporting TLS1.2 and TLS1.3
[tls.options]
[tls.options.default]
sniStrict = true
minVersion = "VersionTLS12"
curvePreferences = [
"secp521r1",
"secp384r1"
]
cipherSuites = [
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305",
"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305",
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
]
[tls.options.mintls13]
minVersion = "VersionTLS13"
```
### .env
```bash
RFC2136_NAMESERVER=...
RFC2136_TSIG_ALGORITHM=hmac-sha512.
RFC2136_TSIG_KEY=...
RFC2136_TSIG_SECRET=...
```
Finally, create an empty acme.json and traefik.log file to handle the certificate and log file for any logging
```bash
touch acme.json traefik.log
chmod 600 acme.json traefik.log
```
> [!WARNING]
> These configurations use DOMAIN_NAME (i.e.: example.com) and HOST_NAME (i.e.: servername) throughout it. You should replace these with your server's name. HOST_NAME.DOMAIN_NAME refers to the machine itself (ie: servername.example.com). Don't forget to update `traefik.toml`'s YOU@DOMAIN_NAME with your email address. Let's Encrypt does not require a valid email but invalid e-mails may be flagged as fake.
Launch the Traefik and Jellyfin services.
```bash
docker-compose up -d
```
If you set a PathPrefix (i.e. /jellyfin), you need to configure Jellyfin to expect it. After starting the service, access Jellyfin directly (via the host's IP at port 8096) and change the 'Base URL' in Dashboard / Advanced / Networking to match the '/jellyfin' path (if you used one in this configuration). Afterward, you may wish to create a firewall rule to prevent direct access to Jellyfin at port 8096 on the host, or simply ensure the port is not accessible via the Internet.
Congratulations, your stack with Traefik 2.x and Jellyfin is (hopefully) running! Check the log file or run without the '-d' parameter to review any errors that may come up, particularly with respect to the LetsEncrypt configuration.

3
docs/server/_category_.json
View File

@ -1,3 +0,0 @@
{
"label": "Server administration"
}

16
docs/server/devices.md
View File

@ -1,16 +0,0 @@
---
id: server-devices
title: Devices
---
# Devices
You can view all devices that have connected to the server from the settings. This will include both currently connected devices and any that have connected in the past. At the moment this page is really only useful to see connected devices and what users are registered to them.
## Options
The only option available at the moment is editing the display name. This can be useful for adding names that can better identify devices. The original name will stay visible in the options if you modify the value.
## Remove
If you don't want to keep old devices on the server you can remove them from this page. Please note that if a device connects again it will show up here. Removing a device does not hide the device forever, it simply cleans out old entries.

37
docs/server/dlna.md
View File

@ -1,37 +0,0 @@
---
id: network-dlna
title: DLNA
---
## DLNA
DLNA is based on uPnP.
DLNA will send a broadcast signal from Jellyfin.
This broadcast is limited to Jellyfin's current subnet.
If you are using docker, the network should use Host Mode, otherwise the broadcast signal will only be sent in the bridged network inside of docker.
If DLNA fails to bind properly, the message `[ERR] Failed to bind to port 1900: "Address already in use". DLNA will be unavailable` should appear in the logs.
Setting `Alive message interval (seconds)` to 30 seconds also appears to help discovery for some clients.
If a base URL is set, try removing it and restarting the server.
### DLNA Logging
Use these entries in `logging.default.json` to turn on DLNA debug logs.
```json
{
"Serilog": {
"MinimumLevel": {
"Default": "Warning",
"Override": {
"Microsoft": "Warning",
"System": "Warning",
"Emby.Dlna": "Debug",
"Emby.Dlna.Eventing": "Debug"
}
}
}
}
```

24
docs/server/libraries.md
View File

@ -1,24 +0,0 @@
---
id: server-libraries
title: Libraries
---
# Libraries
Libraries are virtual collections of media and can contain files from several different locations on the server.
You will see a page to add libraries when you first create the server, but they can also be added or removed at any time from the settings.
1. Log in to the Jellyfin web interface in your web browser.
2. On the menu that appears, click `Admin` > `Dashboard`.
3. Then again on the left side menu go to `Server` > `Libraries`.
4. Click "Add Media Library".
5. The server will now add your new media. There will be a progress bar at the top of the page indicating its progress.
## Content
The three most common types of content are movies, shows, and music. These will have the best support in client apps. You can also add other types of media such as books or photos. If you have several types of media in a single folder you can also label it as mixed, which will be a generic folder view that displays all files in the library.
## Paths
You can add multiple paths that will all be shown under the same library. The path selection dialog will allow you to select folders visually, but if you can't find the exact location you can also just enter the path manually.

43
docs/server/live-tv.md
View File

@ -1,43 +0,0 @@
---
id: live-tv
title: Live TV
---
# Live TV
Jellyfin allows you to watch and record live television using supported hardware. The first step is setting up a tuner to send data to Jellyfin, and then configure a source for the program guide data.
[Click here](xref:server-live-tv-setup-guide) for the general setup guide.
## Tuner
Jellyfin has support for the following tuners:
* HDHomeRun
* M3U
HDHomeRun is a special case because they will usually get detected automatically by the server. Otherwise you can manually add tuners by navigating to **Live TV** in the settings and adding one there.
> [!NOTE]
> Docker users using HDHomeRun devices should set networking to host mode as Jellyfin needs to connect to a changing UDP port.
M3U allows you to add IPTV channel playlists which you can view and record.
Additional tuner types are available via plugins.
## Guide
Guide data will need to be mapped to their corresponding channels after a guide data provider is configured. The guide data formats below are included with the server:
* Schedules Direct
* XMLTV
[Schedules Direct](http://www.schedulesdirect.org) is a paid service providing electronic program guide data to the United States and Canada.
[XMLTV](http://wiki.xmltv.org/index.php/Main_Page) is "... an XML based file format for describing TV listings. IPTV providers use XMLTV as the base reference template in their systems, and extend it internally according to their business needs."
## Status
You can view the status of each tuner connected to the server in the settings. There are also buttons to manually refresh the tuners if they experience problems.
The guide data can be refreshed manually if you run into problems. This isn't normally required since the data is refreshed periodically.

16
docs/server/notifications.md
View File

@ -1,16 +0,0 @@
---
id: server-notifications
title: Notifications
---
# Notifications
You can use notifications to get alerts when certain events happen on your server. Some common notifications include plugin installations and different user events.
## Services
Notifications can be sent using different services depending on what kind of integration you want. Jellyfin will show notifications on the dashboard by default, but you can install alternative services on the **Plugins** page. Most services will require additional configuration but can be extremely useful for those who want instant updates for activity on their server.
## Configuration
You can properly configure this feature on the **Notifications** page in the settings. All notification types will be shown in a list as well as their current status. They can be enabled individually and can be set to only monitor specific users. Any installed notification services will show up in a list in this section.

28
docs/server/quick-connect.md
View File

@ -1,28 +0,0 @@
---
id: server-quick-connect
title: Quick Connect
---
# Quick Connect
Starting with Jellyfin server version 10.7.0 and supported clients, you can use Quick Connect to sign in to your account without the need of a password. You need to previously be logged into a supported client, like the default Jellyfin Web Client.
## Enabling Quick Connect
To use Quick Connect, the Jellyfin server admin has to enable this feature in the server dashboard.
Settings > Dashboard > Quick Connect > Enable quick connect on this server
## Using Quick Connect
To sign in to a supported client, you have to start the Quick Connect pairing in your user settings.
Settings > Quick Connect > Activate
![image](https://user-images.githubusercontent.com/12074633/115973526-aecc6000-a523-11eb-9ed6-59bee41bac7b.png)
Now you can start the sign in process on your new device. If the code is validated successfully, your new device will be signed in without entering your Jellyfin username or password on the new device.
The client will generate a 6 digit code, which you have to enter in the already signed in client in your user settings.
![image](https://user-images.githubusercontent.com/12074633/115973542-c99ed480-a523-11eb-9d61-17ccd628e123.png)

20
docs/server/settings.md
View File

@ -1,20 +0,0 @@
---
id: server-settings
title: Settings
---
# Settings
The general settings include options that don't require their own link in the sidebar. Most of these are items that will change the interface or user experience.
## Server Name
This name will be displayed to users when they select a server, and clients might use it in other locations as well. The default value will be the hostname of the computer.
## Login Disclaimer
This message will be shown to users when they login on your server.
## Custom Style
You can add custom CSS rules for minor changes to the web interface that don't require their own theme.

31
docs/server/storage.md
View File

@ -1,31 +0,0 @@
---
id: server-storage
title: Storage
---
## Storage
Jellyfin is designed to directly read media from the filesystem. This means to pass a network storage device that is using samba or NFS must be directly mounted to the OS. The Jellyfin database also should be stored locally and not on a network storage device.
## Docker or VM's
For storage, a moderate size library database can grow anywhere from 10 to 100 GB. The [transcoding](xref:server-transcoding) folder needs roughly the same size as the original media if it's being transcoded at the same bitrate. A single 50GB Blu-Ray Remux by itself can take up to approximately 60GB or as little as 15GB, depending on the quality selected. If the transcoding folder is held on the same storage as the database, this must be taken into consideration.
## Cloud
A popular choice for cloud storage has been the program [rclone](https://rclone.org/downloads/). It is supported on most Operating Systems. To facilitate combining local and cloud filesystems, rclone can be paired with another program such as [mergerfs](https://github.com/trapexit/mergerfs). For cloud storage, it is recommended to disable image extraction as this requires downloading the entire file to perform this task.
> [!NOTE]
> The image extractor can't be [turned off](https://github.com/jellyfin/jellyfin/issues/2355) in Jellyfin at the moment which is causing [performance issues](https://github.com/jellyfin/jellyfin/issues/2600).
- animostiy22's [repo](https://github.com/animosity22/homescripts) about rclone and mergerfs.
- animosity22's [rclone config](https://github.com/animosity22/homescripts/blob/master/systemd/rclone.service).
### MergerFS
MergerFS isn't meant for everything, [see here](https://github.com/trapexit/mergerfs#what-should-mergerfs-not-be-used-for) for more.
- rclone recommended [config](https://forum.rclone.org/t/my-best-rclone-config-mount-for-plex/7441).
- animosity22's [mergerfs config](https://github.com/animosity22/homescripts/blob/master/systemd/gmedia.service).
To modify and examine your mergerfs mount, here's a quick [guide](https://zackreed.me/mergerfs-neat-tricks).

12
docs/server/tasks.md
View File

@ -1,12 +0,0 @@
---
id: server-tasks
title: Tasks
---
# Tasks
Tasks include any operations that are either too time consuming to always run within a library scan or not directly related to scanning media. One such example of a task is the option to clean out old log files. They can either be run on demand by clicking the run button on the right of a task or at specific times by creating a trigger.
The triggers can be set daily or weekly to run at a set time or on a specific interval if the former two are insufficient. There is also an option to simply run the task every time the server starts running. You can add more than one trigger depending on how often you want to run the task.
Plugins can add their own tasks if they include operations that need to be run at specified intervals. These will also show up in the settings for you to configure.

28
docs/server/transcoding.md
View File

@ -1,28 +0,0 @@
---
id: server-transcoding
title: Transcoding
---
# Transcoding
These settings will relate to backend options that modify how the server transcodes media. Some improve or change the media quality while others reduce the resources required to transcode the media from its original format.
## Hardware Acceleration
If your hardware supports this you can enable [hardware acceleration](xref:admin-hardware-acceleration) for much faster transcoding. Some of the supported methods are listed below.
* VAAPI
* NVENC
## Thread Count
This option will manually set the amount of threads to use when transcoding. If you're not using the server for anything else it's best to leave this option alone.
## Types of Transcoding
There are three types of transcoding. The type being used will be listed in the dashboard when playing a file. They are ordered below from lowest to highest load on the server:
* Direct Play: Delivers the file with no modifications. Almost no additional load on the server.
* Remux: Changes the container but leaves both audio and video streams untouched.
* Direct Stream: Transcodes audio but leaves original video untouched.
* Transcode: Transcodes the video stream.

3
docs/server/users/_category_.json
View File

@ -1,3 +0,0 @@
{
"label": "Users"
}

136
docs/server/users/adding-managing-users.md
View File

@ -1,136 +0,0 @@
---
id: server-users-managing
title: Managing Users
---
# Managing Users
User management can be done under `Users` in the `Dashboard`. Here you can see your current users or add new ones. And manage your users' settings.
## Adding a User
To add a new user, click the `+` symbol at the top of the page. This will open a new page where you can enter the user's name as it will be either displayed on, or has to be typed into login screen. By default, this will be displayed, but this can be changed at any point by modifying the user, explained further down.
### Manage User Library Access
By default the `enables access to all libraries` option will be enabled, disabling this option will enable you to give the user access rights per library, libraries can consist of several folders. When adding new libraries any user that did not have access to `all libraries` will not receive the rights to open the new library, but this can be changed at any point by modifying the user, explained further down.
## Manage a User
To manage a user either click on their portrait to go straight to their `Profile` tab, or click the `...` symbol inside that user's portrait. The later will open a small submenu with the options `Open` `Library access` `Parental control`, and `delete`. Except for delete, which does the obvious, these options will lead to different tabs but are otherwise all on the same page. `Open` corresponds to the Profile tab, `Library access` to access, `Parental control` to Parental Control, and there is an additional fourth tab `Password` for Password control. Changes to any option on any of these tabs need to be saved using `Save` at the bottom of the page.
### Profile
Directly under the tabs you have a link to `Edit this user's profile, image and personal preferences.` Clicking that allows you to change the user's personal settings, any setting here can be changed by both user and admin.
Under `name` you can change the user's name as it will be either displayed on, or has to be typed into login screen.
Under `Authentication Provider` you have the option to change the backend that handles the login, by default the only option here will be `default` which means Jellyfin will handle this user, this option is sufficient for most use cases. Currently, the only other possibility is to have a LDAP server handle the login by installing the LDAP-Auth plugin. Note that if you wish to change a user's provider to LDAP after creating it in Jellyfin the username needs to be identical to the user's UID in LDAP, including capitalization.
`Allow remote connections to this Jellyfin Server.` Unchecking this option will block login attempts this user makes from outside the networks defined as local, by default this will only be the subnet assigned to your network. But more can be added.
#### Feature Access
For the following options it should be noted that if you never set up Live TV, users are blocked regardless of the state. See [the docs page for `Live TV` » `Live TV`](xref:server-live-tv-index) for more information.
`Allow Live TV access` Unchecking this option will block the user's access to watch Live TV.
`Allow Live TV recording management` Unchecking this option will block the user's access to set recording schedules.
#### Media Playback
`Allow media playback` Unchecking this option will block the user's access to media libraries, this does not include Live TV.
> [!NOTE]
> More information about transcoding can be found [here](xref:server-transcoding).
`Allow audio/video playback that requires transcoding` Unchecking this option will block the user's access to video playback that requires transcoding.
`Allow video playback that requires conversion without re-encoding` Unchecking this option will block the user's access to video playback that requires conversion without re-encoding.
`Internet streaming bitrate limit (Mbps)` Under this option you can set an per stream bitrate limit for all out of network devices.
#### Allow Media Deletion From
These checkboxes allow a user to remove media for either `All libraries`, or per Library. Be careful when enabling these as some plugins enable automatic removal of media after watching.
#### Remote Control
These allow a user to control other devices that are currently logged into Jellyfin, for example if you run a separate client on a HTPC without remote control.
`Allow remote control of other users` Allows this user to control what other users are playing and send messages, but does not give them administrative rights.
`Allow remote control of shared devices` Allows this user to control unclaimed DLNA devices, and devices they are logged in to at the moment.
#### Download & Sync
These allow a user to download media. Syncing and Transcoding are currently not available.
#### Additional options
`Allow media conversion` This option is currently not available.
`Allow social media sharing` Allows this user to share the url to web pages containing media information, for example when viewing information about a movie, series, season, or episode.
`Disable this user` Blocks the user from logging in, existing connections will be abruptly terminated.
`Hide this user from login screens` Useful for private or hidden administrator accounts. The user will need to sign in manually by entering their username and password. All newly created users are hidden by default.
#### Locking and Unlocking users
Locking
`Failed login attempts before user is locked out` Determines how many incorrect login attempts can be made before lockout occurs, disabling the user. 0 means inheriting the default of 3 for non-admin and 5 for admin, -1 disables lockout
When a user is locked out after the set amout of attempts the admin has determined for that account, the user will recieve the following message when trying to login to the Jellyfin instance:
```sh
Connection Failure
We\'re unable to connect to the selected server right now. Please ensure it is running and try again.
```
Unlocking
The unlocking of a user is a manual process for the Jellyfin administrator. When a user is locked out a message of the lockout appears on the activity feed on the administrator dashboard. To unlock the user, the administrator needs to navigate to the profile of the locked out user. When on the profile of the locked out user, the following message should appear:
```sh
This user is currently disabled
See below to reenable
```
To reenable the user the administrator must navigate to the `Disable this user` option in the Additional options section uncheck the checkmark and hit `Save`. The disabled user should be able to login again.
### Library Access
These options allow you to restrict access to libraries, or from devices.
`Enable access to all libraries` By default the `Enable access to all libraries` option will be enabled, disabling this option will enable you to give the user access rights per library, libraries can consist of several folders. When adding new libraries any user that did not have access to `all libraries` will not receive the rights to open the new library.
`Enable access from all devices` By default the `Enable access from all devices` option will be enabled, disabling this option will enable you to give the user access rights per device and logins from new devices are blocked until they've been approved here.
### Parental Control
These options allow you to restrict access to specific content by this user or the timeframe in which they may access. Content that matches these restrictions will be hidden, while the timeframe effectively disables the user.
`Maximum allowed parental rating` Allows you to select the highest rating **allowed to show up** for this user.
`Block items with no or unrecognised rating information` Allows you to always hide items with no or unrecognised rating information.
`Block items with tags` Allows you to always hide items when they contain specific tags, you can add tags to items by editing their metadata.
`Access Schedule` Allows you to set the timeframe(s) where this user is allowed to login, media can only play during the timeframe and will be stopped past it.
### Password
Allows you to set or change the user's password. Note that users can change their own passwords in their personal settings.
`Reset Password` will allow the user to log in without giving a password.
If the user has a password, additional options are shown.
`Easy Pin Code` The user's easy pin code is used for offline access with supported clients, and can also be used for easy in-network sign in.
`Enable in-network sign in with my easy pin code` If enabled, the user will be able to use their easy pin code to sign in to Jellyfin apps from inside the local network. Their regular password will only be needed outside the local network. If the pin code is left blank, they won't need a password within the local network. By default, the local network will only be the subnet assigned to your network, but more can be added.
> [!NOTE]
> [Pin-less Sign in Bug](https://github.com/jellyfin/jellyfin/issues/2125#issuecomment-566400711)

34
docs/server/users/index.md
View File

@ -1,34 +0,0 @@
---
id: server-users-index
title: Users
---
# Users
Many features are configurable for each user individually to allow administrators more granular control over a Jellyfin server. Keep in mind that Jellyfin users are entirely local and no information or metadata will ever be sent to remote servers during the login process.
## Basic Overview
### Administrators
To add another administrator you can simply check the box labeled `allow this user to manage the server` at the top of the user options. This will give someone full access to all pages and features on the site so be careful who gets access.
### Playback
You can allow transcoding for audio and video individually to prevent certain people from using too much system resources. There is also an option to enable video playback that doesn't require encoding. This is much less CPU intensive and will often fix playback issues on devices that don't support newer video formats.
### Deletion
Users can delete media from the library with this option, which will also remove them from the filesystem. If your server doesn't have write permission to the media files they will be removed temporarily but picked up on the next library scan. You can also enable this option for individual libraries.
### Locking/Unlocking
You can set a maximum of failed login attempts before a user gets locked out. This means that if a user tries to login but fails an x amount of times. The user will no longer be able to login until the server administrator manually unlocks the account.
### Other
If you disable a user they will be kicked off the server immediately and unable to login until the option is deselected. This is useful if you don't want to expose unused credentials on a public server but might want to keep the account around for a while. You can also hide a user from the login screen and require manual entry of both the username and password. This will prevent users from knowing what accounts have been created on the server when they login.
## Advanced Overview
For more in-depth information on all user settings, see [Managing Users](xref:server-users-managing).

85
docs/setup-live-tv.md
View File

@ -1,85 +0,0 @@
---
id: setup-live-tv
title: Setting up live TV
sidebar_position: 5
---
## Add a TV Tuner to Jellyfin (Automatic Discovery)
Click on the Admin Panel Icon in the top right corner (1)
Click 'Live TV' (2) under the 'Live TV' section
Click the '+' button (3) next to 'Tuner Devices'
![How to access the 'Tuner Devices' page](/images/docs/live-tv-setup-tuner1.png)
Click 'Detect My Devices' from the 'Live TV Tuner Setup' page that opens
Jellyfin will search and hopefully find your tuner automatically:
![An example of detected TV tuner devices](/images/docs/live-tv-setup-tuner2.png)
Click on the device you'd like to set up then set any options then click 'Save'
![Saving TV tuner setup](/images/docs/live-tv-setup-tuner3.png)
## Add a TV Tuner to Jellyfin (Manual Setup)
You can set up your tuners manually if they were not automatically discovered. Click the 'Tuner Type' pull down. Choose between 'HD Homerun', 'M3U Tuner', and 'Other'
![Manually adding a TV tuner](/images/docs/live-tv-setup-tuner4.png)
### HDHomeRun Specific Options
* Tuner IP Address is the URL of your HDHomeRun device. The format will be `http://YOUR.IP.ADDRESS`
* Allow hardware transcoding will allow the tuner to transcode the video on the fly which can reduce server load. Not all HDHomeRun devices support hardware transcoding.
* Restrict to channels marked as favorite will only import channels that are designated as favorite channels on the tuner. This helps if your tuner autoscans and adds new channels that you do not want and/or adds channels that you are able to receive due to atmospheric conditions but later are not accessible.
To set a favorite, go to the [HDHomeRun website](http://my.hdhomerun.com), select your tuner and then click on the grey star next to the channel name to change the star to yellow. The yellow star indicates a favorited channel. In this example, only the channels with yellow stars will be imported into Jellyfin
![Selecting favorites in HDHomeRun](/images/docs/live-tv-setup-hdhr_opt1.png)
### M3U Tuner Specific Options
This tuner allows you to add IPTV channel to Jellyfin by using the appropriate M3U8 playlist file.
* File or URL is the location of the M3U8 playlist. The file can either be stored online at a web (HTTP) address or stored locally.
* User agent is needed in special cases where you need to supply a custome HTTP header to access the remotely stored M3U8 playlist
* Simultaneous stream limit will restrict the number of streams the server can have open at one time. Setting this value to '0' will allow for unlimited streams
* Auto-loop live streams is sometimes necessary for some IPTV channels. Turn this on only if your streams are not playing correctly
> [!NOTE]
> Here is a list of legal samples to use to test connectivity.
>
> [LegalStream Live News Playlist](https://raw.githubusercontent.com/notanewbie/LegalStream/master/packages/news/live.m3u8)
## Adding Guide Data
Guide data is necessary for scheduling tv recordings and for browsing what's currently playing and what will air later. Follow these steps once you have a tuner device set up. Click on the Admin Panel Icon in the top right corner, Click 'Live TV' (2) under the 'Live TV' section, Click the '+' button next to 'TV Guide Data Providers' :
![How to add guide data](/images/docs/live-tv-setup-guide1.png)
Choose between 'Schedules Direct' and 'XMLTV'. You currently cannot use both at the same time.
**Schedules Direct:**
Schedules Direct is a paid service that provides U.S. and Canadian guide data for use in OSS projects. The price is $25 a year and has not increased since it began in 2007. The guide data is highly reliable. You will have to create an account at their [website](http://www.schedulesdirect.org).
**XMLTV:**
This option allows for downloading of guide data in the [XMLTV](http://wiki.xmltv.org/index.php/XMLTVFormat) format.
## Mapping Channels
Guide data from the 'TV Guide Data Providers' will need to be mapped to the physical channel from the tuner. Click the '...' next to the guide provider you set up and select 'Map Channels'
![Step 1 of mapping channels](/images/docs/live-tv-setup-channels1.png)
The list of physical channels will be displayed. Click the pencil icon to the right of the channel and then select the corresponding channel from the guide provider to map the channel. Do this for all channels. Click the left arrow at the top left of the window to exit and save the information.
![Step 2 of mapping channels](/images/docs/live-tv-setup-channels2.png)
The guide data will now automatically imported. You can check that the data has been imported correctly by going to the 'Live TV Guide' page from the main Jellyfin web page on your server.

3
docs/tips-and-tricks/_category_.json
View File

@ -1,3 +0,0 @@
{
"label": "Tips & tricks"
}

538
docs/tips-and-tricks/css-customization.md
View File

@ -1,538 +0,0 @@
---
id: clients-css-customization
title: CSS Customization
---
# CSS Customization
In `Dashboard > General`, the "Custom CSS" field can be used to override current CSS in Jellyfin's stylesheet.
[Custom CSS](https://developer.mozilla.org/en-US/docs/Web/CSS) provides customization such as changing colors, changing layouts, and item size and behavior. Below is a list of various tweaks that can be applied. The CSS tweaks work on both the web client, and the [Android application](https://play.google.com/store/apps/details?id=org.jellyfin.mobile&hl=en_US). The code will apply in the order that it is written, however `!important` will overrule everything. To learn more about `!important` and more, see [CSS Specificity](https://developer.mozilla.org/en-US/docs/Web/CSS/Specificity) or [specifishity](https://specifishity.com/). To implement these changes, go to `Dashboard > General > Custom CSS` to start.
If you have little or no experience with CSS, various resources and tutorials can be found online. Using the tweaks and examples below makes it quite easy to get started with making your own changes to your Jellyfin instance.
![Screenshot of the 'Custom CSS' setting in the administrator dashboard of the web client](/images/docs/custom-css-customcssfield.png)
## General Information About CSS
You can learn more about CSS using sites like [w3schools](https://www.w3schools.com/css/default.asp) and [MDN](https://developer.mozilla.org/en-US/docs/Web/CSS). Below are some very basic CSS knowledge that will let you do rough edits to the pre-made tweaks below.
### Colors
CSS supports multiple color formats, but typically the hex color codes are used for specific colors. To get a specific color, exact color data such as the hex codes below have to be used.
Some examples of hex color codes:
* Green: `#5dd000`
* Blue: `#0000d0`
* Red: `#d00000`
* Transparent Black: `#00000058`
Go [here](https://htmlcolorcodes.com/color-picker) for a hex color chart to get a code for any given color.
If you are looking for a more standard and less specific color, typing the literal name of colors suits that purpose well. For example, to get the color "yellow" you can simply write "yellow", this will use a preset yellow color.
`yellow` Yellow <br />
`red` Red <br />
`aquamarine` Aquamarine <br />
`lightseagreen` Light Sea Green
Go [here](https://www.w3schools.com/colors/colors_names.asp) for a list of color names supported.
### Comments
A section of code or text inbetween `/*` and `*/` indicates a comment, and will be ignored.
This allows you to add descriptions for any particular section of code.
It can also be used to disable code without deleting it.
`/* This might be added above code to tell you what it does */`
### CSS Chaining
CSS can be "chained" together to modify different sections together at the same time. An example of this is the "Border Color" tweak. It lists the elements to be modified, and performs a change that is applied to all of them.
"Border Color" tweak:
```css
.emby-input, .emby-textarea, .emby-select { border-color: #d00000; }
```
## Tweak List
To apply any one of these tweaks, copy and paste the CSS code from the example into the "Custom CSS" field. To use multiple tweaks, simply add them one after another into the field. Any applied code will remain in the field. To remove a tweak, delete or comment out the code for it from the field. Changes apply immediately when the settings page is saved and doesn't require restarting your Jellyfin server.
### Played Indicator
This will affect the played/watched indicator. Replace the hex color with any value you like.
### Indicators Without Tweak
![Screenshot of the default watched indicators](/images/docs/custom-css-normalwatched.png)
### Green Indicators
```css
.playedIndicator { background: #5dd000; }
```
![Screenshot of watched indicators with a custom green color applied](/images/docs/custom-css-greenwatched.png)
### Transparent And Dark Indicators
```css
/* Make watched icon dark and transparent */
.playedIndicator {background: #00000058;}
```
![Screenshot of watched indicators with a custom transparent color applied](/images/docs/custom-css-transparentwatched.png)
### Remove Home Icon from Header
```css
.headerHomeButton { display: none; }
.headerButton.headerButtonRight.headerUserButton.paper-icon-button-light { display: none; }
```
### Remove Cast Icon from Header
```css
.headerCastButton { display: none; }
```
### Remove Sync Icon from Header
```css
.headerSyncButton { display: none; }
```
### Remove User Settings from Header
```css
.material-icons.person { display: none; }
```
### Remove Live TV Channel Listings
```css
.guideChannelNumber { display: none; }
```
### Reduce Live TV Channel Width
```css
.channelsContainer { max-width: 8em; }
```
### Remove Cast & Crew
```css
#castCollapsible { display: none; }
```
### Remove More Like This
```css
#similarCollapsible { display: none; }
```
### Hide Next Up
```css
div.nextUpSection { display: none; }
```
### Background Image on Login Page
```css
#loginPage {
background: url("https://i.ytimg.com/vi/avCWDDox1nE/maxresdefault.jpg");
background-size: cover;
}
```
### Background Image on Homepage
```css
.backdropImage { display: none; }
.backgroundContainer {
background-color: rgba(0, 0, 0, 0);
background-image: url("https://i.ytimg.com/vi/avCWDDox1nE/maxresdefault.jpg");
filter: blur(10px);
background-size: cover;
}
```
[Additional MDN Documentation](https://developer.mozilla.org/en-US/docs/Web/CSS/background)
### Transparent Top Menu
```css
.skinHeader.focuscontainer-x.skinHeader-withBackground.skinHeader-blurred {background:none; background-color:rgba(0, 0, 0, 0);}
.skinHeader.focuscontainer-x.skinHeader-withBackground.skinHeader-blurred.noHomeButtonHeader {background:none; background-color:rgba(0, 0, 0, 0);}
```
### Image Edge Rounded
```css
.cardContent-button,
.itemDetailImage {
border-radius: 0.25em;
}
```
### Enlarge Tab Buttons
Enlarges the tab buttons, suggested, genres, etc. By default they are really tiny, especially on mobile.
```css
/* Adjust both "size-adjust" and "size" to modify size */
.headerTabs.sectionTabs {text-size-adjust: 110%; font-size: 110%;}
.pageTitle {margin-top: auto; margin-bottom: auto;}
.emby-tab-button {padding: 1.75em 1.7em;}
```
**The enlarged tab buttons and transparent menu look like this:**
![Screenshot of enlarged tab buttons and transparent menu](/images/docs/custom-css-transparenttopbarenlargedtabs.png)
### Minimalistic Login Page
This looks even better together with the transparent top menu!
```css
/* Narrow the login form */
#loginPage .readOnlyContent, #loginPage form {max-width: 22em;}
/* Hide "please login" text, margin is to prevent login form moving too far up */
#loginPage h1 {display: none}
#loginPage .padded-left.padded-right.padded-bottom-page {margin-top: 50px}
/* Hide "manual" and "forgot" buttons */
#loginPage .raised.cancel.block.btnManual.emby-button {display: none}
#loginPage .raised.cancel.block.btnForgotPassword.emby-button {display: none}
```
![Screenshot of the minimalistic login page](/images/docs/custom-css-minimallogin.png)
### Stylized Episode Previews
The episode previews in season view are sized based on horizontal resolution. This leads to a lot of wasted space on the episode summary and a high vertical page, which requires a lot of scrolling. This code reduces the height of episode entries, which solves both problems.
```css
/* Size episode preview images in a more compact way */
.listItemImage.listItemImage-large.itemAction.lazy {height: 110px;}
.listItem-content {height: 115px;}
.secondary.listItem-overview.listItemBodyText {height: 61px; margin: 0;}
```
![Screenshot of a TV show page with stylized episode previews](/images/docs/custom-css-episodepreview.png)
### Stylized and Smaller Cast & Crew Info
This will drastically change the style of cast info into something very similar to how Plex approaches it. This override will lead to somewhat smaller thumbnails, and also works with all themes.
```css
/* Shrink and square (or round) cast thumnails */
#castContent .card.overflowPortraitCard.personCard.card-hoverable.card-withuserdata {width: 4.2cm !important; font-size: 90% !important;}
#castContent .card.overflowPortraitCard.personCard.card-withuserdata {width: 4.2cm !important; font-size: 90% !important;}
/* Correct image aspect ratio behaviour, set border-radius to zero for square tiles */
#castContent .cardContent-button.cardImageContainer.coveredImage.cardContent.cardContent-shadow.itemAction.lazy {background-size: cover; !important; border-radius: 2.5cm;}
#castContent .cardContent-button.cardImageContainer.coveredImage.defaultCardBackground.defaultCardBackground1.cardContent.cardContent-shadow.itemAction {background-size: cover; !important; border-radius: 2.5cm;}
#castContent .cardContent-button.cardImageContainer.coveredImage.defaultCardBackground.defaultCardBackground2.cardContent.cardContent-shadow.itemAction {background-size: cover; !important; border-radius: 2.5cm;}
#castContent .cardContent-button.cardImageContainer.coveredImage.defaultCardBackground.defaultCardBackground3.cardContent.cardContent-shadow.itemAction {background-size: cover; !important; border-radius: 2.5cm;}
#castContent .cardContent-button.cardImageContainer.coveredImage.defaultCardBackground.defaultCardBackground4.cardContent.cardContent-shadow.itemAction {background-size: cover; !important; border-radius: 2.5cm;}
#castContent .cardContent-button.cardImageContainer.coveredImage.defaultCardBackground.defaultCardBackground5.cardContent.cardContent-shadow.itemAction {background-size: cover; !important; border-radius: 2.5cm;}
#castContent .cardScalable {width: 3.8cm !important; height: 3.8cm !important; border-radius: 2.5cm;}
#castContent .cardOverlayContainer.itemAction {border-radius: 2.5cm;}
/* Center the mouseover buttons */
#castContent .cardOverlayButton-br {bottom: 4%; right: 15%; width: 70%;}
#castContent .cardOverlayButton.cardOverlayButton-hover.itemAction.paper-icon-button-light {margin:auto;}
```
![Screenshot of stylized and smaller Cast & Crew info](/images/docs/custom-css-stylizedcast.png)
### Pictureless Cast & Crew
```css
#castContent .card.overflowPortraitCard { width: 4.2cm; font-size: 90%; }
#castContent .personCard { width: auto; }
#castContent .personCard .cardBox { margin-bottom: 0px; margin-right: 0px; }
#castContent { flex-wrap: wrap; max-height: 9.75em; }
div.personCard > :first-child > :first-child { display: none; }
.itemDetailPage .cardText { text-align: left; }
.itemDetailPage .textActionButton { text-align: left; }
```
![Screenshot of Pictureless Cast & Crew info](/images/docs/custom-css-nopicturecast.png)
### Custom Background Color
```css
.backgroundContainer, .dialog, html { background-color: #0fd0d0; }
```
### Darken the Background
This darkens the background on Blue Radiance and Purple Haze, edit the percentage depending how dark you want it. Lower is darker.
```css
/* Darken background, only works with blue radiance */
.backgroundContainer {background-color: #000000; filter: brightness(50%);}
```
### Right Header Color
This modifies the colors of the cast, search and user buttons in the top right.
```css
.headerRight { color: yellow; }
```
![Screenshot of a custom yellow color for the icon buttons in the top right of the screen](/images/docs/custom-css-rightheader.png)
### Console Panel Custom Color
Modifies the color of the left menu panel.
```css
.mainDrawer-scrollContainer { color: yellow; }
```
![Screenshot of a custom yellow color on the left menu panel](/images/docs/custom-css-consolepanel.png)
### General Page Custom Color
```css
.dashboardGeneralForm { color: yellow; }
```
![Screenshot of a custom yellow color on the General Page](/images/docs/custom-css-generalcolor.png)
### Custom Border Color
This will change the border color for text fields and drop-down menus.
```css
.emby-input, .emby-textarea, .emby-select { border-color: #d00000; }
```
This will affect the border color of highlighted (selected) text fields and drop-down menus.
```css
.emby-input:focus, .emby-textarea:focus, .emby-select-withcolor { border-color: #ffffff !important; }
```
![Screenshot of a custom red border color](/images/docs/custom-css-bordercolor.png)
### Full Header Tweak
```css
.skinHeader, .mainDrawer, .emby-input, .emby-textarea, .emby-select, .navMenuOption-selected, .cardBox, .paperList { background: #ff9475; }
```
![Screenshot of the full header tweak](/images/docs/custom-css-full-header-mod.png)
### Disable Image Carousel for Libraries
This will make it so libraries and media fit neatly onto the homepage with no left to right scrolling required.
```css
@media all and (min-width: 50em) {
.homePage .emby-scroller {
margin-right: 0;
}
.homePage .emby-scrollbuttons {
display: none;
}
.homePage .itemsContainer {
flex-wrap: wrap;
}
}
```
### Shift Scroller Buttons
```css
.emby-scrollbuttons {
position: absolute;
left: 0;
top: 0;
width: 100%;
height: 100%;
padding: 0;
justify-content: space-between;
pointer-events: none;
}
.emby-scrollbuttons-button {
pointer-events: initial;
}
```
### "Hotdogs and Catsup" Color Theme Example
An example of a color theme.
![Screenshot of the "Hotdogs and Catsup" color theme](/images/docs/custom-css-hotdog-and-catsup.png)
```css
.skinHeader, .mainDrawer, .emby-input, .emby-textarea, .emby-select, .navMenuOption-selected, .cardBox, .paperList {
background: #ff9475;
}
.emby-input, .emby-textarea, .emby-select {
border-color: #fdbe7d;
}
.backgroundContainer.withBackdrop, .backdropContainer, .backgroundContainer {
background: #fdbe7d;
}
#myPreferencesMenuPage .listItemBodyText,
.emby-tab-button[data-index="0"],
#myPreferencesMenuPage > div > div > div > a:nth-child(odd),
.button-submit,
.mainAnimatedPage *:nth-child(odd),
.dashboardGeneralForm *:nth-child(odd),
.mainDrawer-scrollContainer *:nth-child(odd),
.headerRight *:nth-child(odd) {
color: red;
}
#myPreferencesMenuPage .listItemIcon,
.emby-tab-button[data-index="1"],
#myPreferencesMenuPage > div > div > div > a:nth-child(even),
.mainAnimatedPage *:nth-child(even),
.dashboardGeneralForm *:nth-child(even),
.mainDrawer-scrollContainer *:nth-child(even),
.headerRight *:nth-child(even)
.cancel {
color: yellow;
}
```
### Floating Now Playing Controls
![Screenshot of the floating "Now Playing" controls](/images/docs/custom-css-floatingnowplaying.png)
```css
/* fixed height for the bottom row */
:root {
--element-fixed-top: 95px;
}
/* Now playing bar in the footer */
.nowPlayingBar {
width: 650px;
z-index: 10;
position: fixed;
top: 300px;
height: 120px;
border-style: solid;
border-color: white;
background-color: black;
margin-left: 50%;
}
/* Only child of nowPlayingBar */
.nowPlayingBarTop {
height: 5px !important;
max-width: 500px
top: 10px;
}
/* Song progress seekbar */
.nowPlayingBarPositionContainer {
position: relative;
top: 1.0em !important;
}
/* Container that holds album thumbnail, artist and album name */
.nowPlayingBarInfoContainer {
position: fixed !important;
left: 12px;
top: 34px;
height: 60px;
width: 1100px;
}
/* Holds the next, previous track, play/pause, next and time elements */
.nowPlayingBarCenter {
position: relative !important;
left: 32px;
top: var(--element-fixed-top);
min-width: 500px;
}
/* Hold mute, volume slider container, repeat, favorite and remote control buttons */
.nowPlayingBarRight {
width: 402px !important;
left: -60px;
}
/* Mute button */
.muteButton {
position: relative;
top: var(--element-fixed-top);
}
/* Volume slider */
.nowPlayingBarVolumeSliderContainer {
position: relative;
left: -4px;
top: var(--element-fixed-top);
}
/* Toggle repeat */
.toggleRepeatButton {
position: relative !important;
left: -20px;
top: var(--element-fixed-top);
}
/* Favorite */
.nowPlayingBarUserDataButtons {
position: relative;
left: -4px;
top: var(--element-fixed-top);
}
/* Remote control */
.remoteControlButton {
left: -110px;
top: var(--element-fixed-top);
}
```
## Community Links
Some links to places where custom CSS has been discussed and shared!
### Community Posts
Keep in mind that these posts may have been made under previous versions of Jellyfin. Some of these tweaks listed in these guides may not work anymore!
* [Custom CSS Guide](https://www.reddit.com/r/jellyfin/comments/fgmu6k/custom_css_updated_for_1050)
* ["But wait, there is more Custom CSS!"](https://www.reddit.com/r/jellyfin/comments/htrfrx/but_wait_there_is_more_custom_css)
* [Customizable Plug n' Play CSS for Jellyfin](https://www.reddit.com/r/jellyfin/comments/g9gmjj/customizable_plug_n_play_css_for_jellyfin)
* [Easy Jellyfin custom CSS](https://www.reddit.com/r/jellyfin/comments/crxqk5/easy_jellyfin_custom_css)
* [Custom CSS - updated for 10.5.0](https://www.reddit.com/r/jellyfin/comments/fgmu6k/custom_css_updated_for_1050)
* [Sharing even more custom CSS (and some fixes to previous stuff)](https://www.reddit.com/r/jellyfin/comments/bvnt65/sharing_even_more_custom_css_and_some_fixes_to)
### Community Themes
* [Monochromic - A custom theme for Jellyfin mediaserver created using CSS overrides](https://github.com/CTalvio/Monochromic)
* [Kaleidochromic - Yet another custom theme for Jellyfin mediaserver created using CSS overrides, built on top of Monochromic](https://github.com/CTalvio/Kaleidochromic)
* [Novachromic - A light theme, built on top of Monochromic](https://github.com/CTalvio/Novachromic)
* [JellyfinCSS - This is Jellyfin custom-css](https://github.com/prayag17/JellyfinCSS)
* [Jellyfin Netflix Dark - The Best Netflix Dark Theme for Jellyfin Around!](https://github.com/DevilsDesigns/Jellyfin-Netflix-Dark)

77
docs/tips-and-tricks/fail2ban.md
View File

@ -1,77 +0,0 @@
---
id: fail2ban-jellyfin
title: fail2ban
---
## Fail2ban
Fail2ban is an intrusion prevention software framework that protects computer servers from brute-force attacks.
Fail2ban operates by monitoring log files (e.g. /var/log/auth.log, /var/log/apache/access.log, etc.) for selected entries and running scripts based on their content.
Jellyfin produces logs that can be monitored by Fail2ban to prevent brute-force attacks on your machine.
### Requirements
* Jellyfin remotely accessible
* Fail2ban installed and running
* Knowing where the logs for Jellyfin are stored: by default /var/log/jellyfin/
### Step one: create a jail
You need to create a jail for Fail2ban.
If you are on Ubuntu and use nano as editor, type:
```bash
sudo nano /etc/fail2ban/jail.d/jellyfin.local
```
And add this to the file:
```bash
[jellyfin]
backend = auto
enabled = true
port = 80,443
protocol = tcp
filter = jellyfin
maxretry = 3
bantime = 86400
findtime = 43200
logpath = /var/log/jellyfin/jellyfin*.log
```
Save and exit nano.
### Step two: create a filter
The filter explains to Fail2ban where to look in the log file. This is the tricky part.
```bash
sudo nano /etc/fail2ban/filter.d/jellyfin.conf
```
And add this to the new file (thanks to @sebres from F2B):
```bash
[Definition]
failregex = ^(?:\[\]\s+)?\[INF\] Authentication request for "[^"]*" has been denied \(IP: "<HOST>"\)\.$
```
Save and exit, then reload Fail2ban:
```bash
sudo systemctl restart fail2ban
```
You're done.
### Step three: test
You can test this new jail:
```bash
fail2ban-regex /var/log/jellyfin/*.log /etc/fail2ban/filter.d/jellyfin.conf
```
And see the output.

230
docs/tips-and-tricks/letsencrypt.md
View File

@ -1,230 +0,0 @@
---
id: network-letsencrypt
title: Let's Encrypt
---
## LetsEncrypt with Certbot
LetsEncrypt is a service that provides free SSL/TLS certificates to users. Certbot is a client that makes this easy to accomplish and automate. In addition, it has plugins for Apache and Nginx that make automating certificate generation even easier.
Installation instructions for most Linux distributions can be found on the [Certbot](https://certbot.eff.org/docs/install.html#operating-system-packages) website.
Once the packages are installed, you're ready to generate a new certificate.
### Apache
#### Certbot Apache Plugin
After installing Certbot and the Apache plugin, certificate generation is accomplished by with the following command.
```sh
certbot certonly --apache --noninteractive --agree-tos --email YOUR_EMAIL -d DOMAIN_NAME
```
Update the 'SSLCertificateFile' and 'SSLCertificateKeyFile' sections, then restart the service.
Add a job to cron so the certificate will be renewed automatically.
```sh
echo "0 0 * * * root certbot renew --quiet --no-self-upgrade --post-hook 'systemctl reload apache2'" | sudo tee -a /etc/cron.d/renew_certbot
```
#### Certbot Webroot
##### Debian
If the certbot apache plugin doesn't work with your config, use webroot instead.
Add the following to your `<VirtualHost>` section after configuring it a reverse proxy:
```conf
DocumentRoot /var/www/html/
#Do not pass the .well-known directory when using certbot and webroot
ProxyPass /.well-known !
```
Run the certbot command as root:
```sh
sudo certbot certonly --webroot -w /var/www/html --agree-tos --email YOUR_EMAIL -d DOMAIN_NAME
```
### HAProxy
HAProxy doesn't currently have a Certbot plugin. To get around this, run Certbot in standalone mode and proxy traffic through your network.
Enable the frontend and backend in the config above, and then run Certbot.
```sh
certbot certonly --standalone --preferred-challenges http-01 --http-01-port 8888 --noninteractive --agree-tos --email YOUR_EMAIL -d DOMAIN_NAME
```
The port can be changed to anything you like, but be sure that the HAProxy config and your Certbot command match.
HAProxy needs to have the certificate and key files concatenated into the same file to read it correctly. This can be accomplished with the following command.
```sh
cat /etc/letsencrypt/live/DOMAIN_NAME/fullchain.pem /etc/letsencrypt/live/DOMAIN_NAME/privkey.pem > /etc/ssl/DOMAIN_NAME.pem
```
Uncomment `bind *:443` and the redirect section in the configuration, then reload the service.
#### Automatic Certificate Renewal
Place the following script in `/usr/local/bin/` to automatically update your SSL certificate.
```sh
SITE=DOMAIN_NAME
# move to the correct let's encrypt directory
cd /etc/letsencrypt/live/$SITE
# cat files to make combined .pem for haproxy
cat fullchain.pem privkey.pem > /etc/ssl/$SITE.pem
# reload haproxy
service haproxy reload
```
Make sure the script is executable.
```sh
chmod u+x /usr/local/bin/letsencrypt-renew.sh
```
Add a job to cron so the certificate will be renewed automatically.
```data
@monthly /usr/bin/certbot renew --renew-hook "/usr/local/bin/letsencrypt-renew.sh" >> /var/log/letsencrypt-renewal.log
```
### Nginx
After installing Certbot and the Nginx plugin with `sudo apt install certbot python3-certbot-nginx`, generate the certificate.
**Note**: For Fedora Linux distributions (e.g. CentOS 8) use `sudo dnf install python3-certbot-nginx` to install the Nginx plugin.
```sh
sudo certbot --nginx --agree-tos --redirect --hsts --staple-ocsp --email YOUR_EMAIL -d DOMAIN_NAME
```
Add the `--rsa-key-size 4096` parameter if you want a 4096 bit key instead.
Copy and paste the whole Nginx sample configuration file from above, changing the parameters according to your setup and uncommenting the lines.
Add a job to cron so the certificate will be renewed automatically.
```sh
echo "0 0 * * * root certbot renew --quiet --no-self-upgrade --post-hook 'systemctl reload nginx'" | sudo tee -a /etc/cron.d/renew_certbot
```
### Let's Encrypt and Docker
This section assumes that Jellyfin is running in a Docker container (on Linux). This section also assumes that you wish to run Let's Encrypt in a Docker container as well. The Linuxserver/swag Docker container has a built-in nginx webserver to handle the reverse proxy.
Linuxserver/letsencrypt is deprecated in favor of linuxserver/swag, see [here](https://github.com/linuxserver/docker-swag#migrating-from-the-old-linuxserverletsencrypt-image) for information on how to migrate if needed.
First, you need to determine a few things.
1. **MAKE SURE YOU HAVE A CNAME FOR JELLYFIN WITH YOUR DNS PROVIDER BEFORE PROCEEDING**
2. Where you wish to store information regarding Let's Encrypt (docker calls these "volumes")
3. What subdomain or subfolder you wish to use with Let's Encrypt (ex. jellyfin.example.com)
4. What timezone you wish to use
5. If you'll be using either HTTP-01 or DNS-01 for challenges.
6. What network you'll be running on (I'd recommend the default macvlan network called "br0")
7. What IP you want your container running on
8. What ports you'll be using (ex. 180 for port 80, and 1443 for 443)
9. Make sure ports 80 (if using http validation) and 443 are forwarded to the docker container from your router (instructions vary upon manufacturer)
10. What user will the container be running as (you can determine the PUID and PGID by running `id` (replacing "user" with the username of the user the container will be running as)
List of DNS Plugins [here](https://certbot.eff.org/docs/using.html#dns-plugins) if using DNS-01 challenge.
Then, depending on what those settings are, you'll need to adjust the values below as needed.
For example, the docker create command from the LinuxServer team for the Swag Docker container:
```sh
docker create \
--name=swag \
--cap-add=NET_ADMIN \
-e PUID=1000 \
-e PGID=1000 \
-e TZ=Europe/London \
-e URL=example.com \
-e SUBDOMAINS=www, \
-e VALIDATION=http \
-e DNSPLUGIN=cloudflare `#optional` \
-e DUCKDNSTOKEN=<token> `#optional` \
-e EMAIL=<e-mail> `#optional` \
-e DHLEVEL=2048 `#optional` \
-e ONLY_SUBDOMAINS=false `#optional` \
-e EXTRA_DOMAINS=<extradomains> `#optional` \
-e STAGING=false `#optional` \
-p 443:443 \
-p 80:80 `#optional` \
-v </path/to/appdata/config>:/config \
--restart unless-stopped \
linuxserver/swag
```
Assuming I follow this template and adjust for my region, ports, and path, it would look like this (with personal information redacted):
```sh
docker create --name=swag --cap-add=NET_ADMIN -e PUID=1000 -e PGID=1000 -e TZ=America/Chicago -e URL=example.com -e SUBDOMAINS=jellyfin -e VALIDATION=http -e EMAIL=email@email.com -e DHLEVEL=2048 -e ONLY_SUBDOMAINS=false -e STAGING=false -p 443:443 -p 80:80 -v /path/to/appdata/swag/:/config --restart unless-stopped linuxserver/swag
```
This will pull down the linuxserver/letsencrypt container, and then create it with the variables specified. You'll then want to start the docker container with `docker start swag`. You can verify this is started by running `docker ps`, which will produce an output like this:
```text
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
09346434b8ea linuxserver/swag "/init" 2 minutes ago Up 5 seconds 0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp swag
```
At this point, navigate to what volume you selected (in my example, it's `/mnt/swag`). You'll then need to navigate to `nginx/proxy-confs` within that directory. If you list the contents of that directory, you'll see a lot of files.
The one we're interested in for jellyfin is `jellyfin.subdomain.conf.sample` (if using a subdomain) or `jellyfin.subfolder.conf.sample` (if using a subfolder). You'll want to copy the file needed, removing the .sample (ex. `cp jellyfin.subdomain.conf.sample jellyfin.subdomain.conf`). Open the file in your text editor of choice.
It should look like this (this file is `jellyfin.subdomain.conf`, although `jellyfin.subfolder.conf` looks very similar):
```nginx
server {
listen 443 ssl;
listen [::]:443 ssl;
server_name jellyfin.*;
include /config/nginx/ssl.conf;
client_max_body_size 0;
location / {
include /config/nginx/proxy.conf;
resolver 127.0.0.11 valid=30s;
set $upstream_app jellyfin;
set $upstream_port 8096;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
proxy_set_header Range $http_range;
proxy_set_header If-Range $http_if_range;
}
location ~ (/jellyfin)?/socket/ {
include /config/nginx/proxy.conf;
resolver 127.0.0.11 valid=30s;
set $upstream_app jellyfin;
set $upstream_port 8096;
set $upstream_proto http;
proxy_pass $upstream_proto://$upstream_app:$upstream_port;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection $http_connection;
}
}
```
The lines we're interested in is `set $upstream_app jellyfin`. Now, assuming Jellyfin and Let's Encrypt are on the same network within Docker, it *should* see it and start handling reverse proxy without much issue. If it doesn't however, you'll just need to change `jellyfin` in that line to whatever the IP of your Jellyfin server is. We'll also look at the line `location ~ (/jellyfin)?/socket` and add a slash after socket, so the line should look like this `location ~ (/jellyfin)?/socket/`.
Then, within Jellyfin settings (Dashboard -> Networking), scroll down to "Public HTTP port number" and "Public HTTPS port number", and make sure HTTP Port number is 8096, while HTTPS port number is 8920.
Restart your Let's Encrypt docker container by running `docker restart swag`, and then you can follow the logs with `docker logs -f swag`. Assuming everything works, you should see `Server Ready` at the very end of the logs. This tells you Lets Encrypt is running without issue.

71
docs/tips-and-tricks/migrations.md
View File

@ -1,71 +0,0 @@
---
id: migrations
title: Migrations
---
Direct database migration from Emby (of any version) to Jellyfin is NOT SUPPORTED. We have found many subtle bugs due to the inconsistent database schemas that result from trying to do this, and strongly recommend that all Jellyfin users migrating from Emby start with a fresh database and library scan.
The original procedure is provided below for reference however we cannot support it nor guarantee that a system upgraded in this way will work properly, if at all. If anyone is interested in writing a database migration script which will correct the deficiencies in the existing database and properly import them into Jellyfin, [we would welcome it however](xref:contrib-index)!
## Watched Status Migration
There are scripts available that will use the API to copy watched status and users from one instance to another. This can be done from Plex, Emby or another Jellyfin instance.
[Emby/Jellyfin to Jellyfin migration](https://github.com/CobayeGunther/Emby2Jelly)
[Plex to Jellyfin migration](https://github.com/wilmardo/migrate-plex-to-jellyfin)
## Unofficial Procedure
> [!WARNING]
> While it is technically possible to migrate existing configuration of Emby version 3.5.2 or earlier, due to subtle and weird bugs reported after such attempts we do not recommend this migration. Emby versions 3.5.3 or 3.6+ cannot be migrated. Thus we recommend creating a new Jellyfin configuration and rebuilding your library instead.
Windows users may take advantage of the `install-jellyfin.ps1` script in the [Jellyfin repository](https://github.com/jellyfin/jellyfin) which includes an automatic upgrade option.
This procedure is written for Debian-based Linux distributions, but can be translated to other platforms by following the same general principles.
1. Upgrade to Emby version 3.5.2, so that the database schema is fully up-to-date and consistent. While this is not required, it can help reduce the possibility of obscure bugs in the database.
2. Stop the `emby-server` daemon:
```sh
sudo service emby-server stop
```
3. Move your existing Emby data directory out of the way:
```sh
sudo mv /var/lib/emby /var/lib/emby.backup
```
4. Remove or purge the `emby-server` package:
```sh
sudo apt purge emby-server
```
5. Install the `jellyfin` package using the [installaton instructions](xref:admin-installing).
6. Stop the `jellyfin` daemon:
```sh
sudo service jellyfin stop
```
7. Copy over all the data files from the Emby backup data directory:
```sh
sudo cp -a /var/lib/emby.backup/* /var/lib/jellyfin/
```
8. Correct ownership on the new data directory:
```sh
sudo chown -R jellyfin:jellyfin /var/lib/jellyfin
```
9. Start the `jellyfin` daemon:
```sh
sudo service jellyfin start
```

28
docs/tips-and-tricks/monitoring.md
View File

@ -1,28 +0,0 @@
---
id: monitoring
title: Monitoring
---
## Monitoring
Jellyfin has two monitoring and metrics endpoints built-in: a basic health check endpoint and a Prometheus-compatible metrics endpoint.
### Health check endpoint
Jellyfin exposes the `/health` endpoint designated for checking the status of the underlying service. Currently this will verify HTTP and database connectivity and return a `200 OK` response if successful. You can see this for yourself by using `curl`:
```sh
curl -i http://myserver:8096/health
```
The `-i` option tells `curl` to also print the HTTP response code and headers.
### Prometheus metrics
Jellyfin can make [Prometheus](https://prometheus.io/) metrics available at `/metrics`, but this is turned off by default to avoid unintentionally leaking this information on the public internet. To enable it, you will need to edit `/etc/jellyfin/system.xml` and change this line from `false` to `true`:
```xml
<EnableMetrics>false</EnableMetrics>
```
If you have a [reverse proxy](xref:network-index#running-jellyfin-behind-a-reverse-proxy) configured, you can configure it to block access to the `/metrics` endpoint except for your internal network.

51
src/pages/community-standards.md
View File

@ -1,51 +0,0 @@
---
title: Community Standards
---
# Community Standards
As time marches on and Jellyfin, and the Internet more broadly, continues to grow, it is important to establish standards by which community members should interact. While there are numerous such "Codes of Conduct" out there, I am not a fan of most, and I felt it important to establish our own, suited to our project, as well as a dispute resolution mechanism tailored to our needs. Questions about this document should be directed towards me. --Joshua, Project Leader
## Mission Statement
* Jellyfin aims to be the best media streaming platform possible, built entirely by volunteers without any monetary gain, proprietary/locked features, or unreasonable centralization.
* Jellyfin is a project made up entirely and exclusively of Volunteers who donate their free time to the project.
* Fostering a community of respectful and productive contributors is central to our success and longevity.
* Jellyfin is not and will never be under the control of any corporation or profit-driven entity, and does not exist to make money for anyone, including any volunteer contributors or the project leadership.
## Code of Conduct
At all times when interacting with the Jellyfin community via any method (Matrix, Reddit, Forums, etc.), you must abide by the following:
* **Respect others and remember the Human.** Do exhibit kindness and empathy to others, and make them feel welcome. Do not antagonize, flame, insult, demean, abuse, or harass others. Do not use slurs or sexualized language. Do not dox or otherwise expose others' private information, even if it is shared publicly elsewhere.
* **English is the primary working language of Jellyfin, but the majority of our community do not speak English as their primary language**. Be patient when language issues arise, and do not mistake incomplete language knowledge for ignorance or worse. Always act in good faith and give other contributors the benefit of the doubt, and try to read positivity rather than negativity into messages where at all possible. If you are having trouble communicating an idea in English, please post in your native language and ask for help, and someone is likely to understand. As per rule 1, abuse of community members due to language issues is not tolerated.
* Jellyfin, as set out in our Mission Statement, is created exclusively by volunteers. As they are freely giving their time and effort, **no volunteer contributor owes anything whatsoever to any other contributor, any user, or the project itself**. Contributors are free to come and go as they please, to work on and give attention to what they deem interesting or important, and to respond or not respond to anything they wish. That said the administrative team would kindly request that regular contributors inform us of long-term departures to ensure we are aware, should the need arise.
* If you have questions to ask of the community, **please choose the appropriate location** (see our [Getting Help](xref:getting-help) page) and **ask your question in full, immediately, with as much detail as possible**. Author issues aside, [Asking Questions the Smart Way](http://www.catb.org/~esr/faqs/smart-questions.html) is a valuable resource. **Do not pester or harass** community members for help or to answer questions, **do not require others to pry information** out of you, and **do not spam questions** - they will be answered when they are answered.
* Jellyfin is a media server system for your own media collection. Our communities are not a place to obtain media. **Do not engage in, encourage, or facilitate piracy**. Do not ask questions about where to obtain media. Do not ask for access to other users' servers, or sell or transfer access to private servers in our communities.
## Dispute Resolution and Moderation
Disputes are inevitable, including violations of the rules above. When these occur, the following policy applies.
* Before any other resolution step, we trust the community to police itself. If you see a community member violating these community standards, please let them know, and link them to this document. Do not respond in kind (e.g. respond to a flame with a flame). Most disagreements can be solved with education and discussion.
* If the issue cannot be resolved between the contributors, any complaints, instances of explicit rulebreaking, or unresolvable disagreements with other community members may be directed towards the Administrative team, or the Project Leaders directly. You may do so through email (`team [at] jellyfin.org`) or on Matrix via a direct message. Please include details and context as appropriate.
* The team will review the complaint and decide on an action, including but not limited to: informal private guidance, informal private warnings, formal public warnings, temporary ban(s) from the various platforms, or permanent ban(s).
* Formal warnings will be made under a "second-chance-only" policy. Once warned, if one repeats the same behaviour, the response will escalate as appropriate to the infraction.
* Moderation tasks in some locations are delegated to other team members. This dispute resolution procedure applies anywhere under the Jellyfin umbrella. The Administrative team and Project Leaders retain final say in any dispute resolutions.
## Changelog
This document represents official Jellyfin project policy. Any changes to this document require a changelog entry here and approval by a Project Leader.
2020-09-14, Joshua Boniface: Initial version of the community standards document. Based *very* loosely on several CoCs including the Contributor Covenant, and various Forum rules I've read and written over the years.

34
src/pages/faq.md
View File

@ -1,34 +0,0 @@
---
title: FAQ
---
# Frequently Asked Questions
## Why fork Emby? Why did you start this project?
We explain our rationale on our [about page](xref:about).
## Why don't you support my favorite client or feature?
We would love to support it!
Unfortunately, no one has decided to develop it yet, so there isn't much we can do.
This is an open source project maintained by developers working entirely in their free time, which usually results in each person working on things they are personally familiar with or plan to use frequently.
If you know a developer that would enjoy your favorite feature send them our way, we will gladly help them get familiar with the project workflow!
## How do I get help?
Please see our [getting help](xref:getting-help) page for details on where to engage the community.
## How can I contribute to this project?
Please see our [contributing guide](xref:contrib-index) page for details on how to get started.
We are always looking for C# and frontend developers, mobile app developers, translators, and documentation writers to help!
## How do I request a new feature?
Please see our [requesting features](xref:contrib-issues#requesting-features) page for details in requesting a new feature in Jellyfin.
## How do I support this project?
All we can ask is you [use Jellyfin](xref:admin-installing), [report any bugs](xref:contrib-issues#reporting-bugs), and tell your friends about us!
Really, we're just people volunteering our time to help build a better media system, so joining the community is the best way to show your support.

38
src/pages/getting-help.md
View File

@ -1,38 +0,0 @@
---
title: Getting Help
---
# Getting Help
If you are having trouble using or configuring Jellyfin, there are several ways to get help. Please ensure you read our [Community Standards](xref:community-standards) before interacting in any of the following locations.
* The Jellyfin [Matrix channels](https://matrix.to/#/+jellyfin:matrix.org): For chat and real-time discussions.
* Some channels are bridged to IRC and Discord.
* The Jellyfin [forums](https://forum.jellyfin.org): For long-term discussions.
* The Jellyfin [subreddit](https://www.reddit.com/r/jellyfin): For general discussions.
We are also active on social media.
* [Facebook](https://www.facebook.com/Jellyfin-319514125331205)
* [Twitter](https://twitter.com/jellyfin)
## Matrix Channels
* <a href="https://matrix.to/#/#jellyfin:matrix.org"><img alt="jellyfin" src="https://img.shields.io/matrix/jellyfin:matrix.org.svg?logo=matrix&label=jellyfin"/></a>: General chat related to the project
* <a href="https://matrix.to/#/#jellyfin-announce:matrix.org"><img alt="jellyfin-announce" src="https://img.shields.io/matrix/jellyfin-announce:matrix.org.svg?logo=matrix&label=jellyfin-announce"/></a>: Announcements for releases and other important information
* <a href="https://matrix.to/#/#jellyfin-troubleshooting:matrix.org"><img alt="jellyfin-troubleshooting" src="https://img.shields.io/matrix/jellyfin-troubleshooting:matrix.org.svg?logo=matrix&label=jellyfin-troubleshooting"/></a>: User troubleshooting
* <a href="https://matrix.to/#/#jellyfin-dev:matrix.org"><img alt="jellyfin-dev" src="https://img.shields.io/matrix/jellyfin-dev:matrix.org.svg?logo=matrix&label=jellyfin-dev"/></a>: Main room for development communication
* <a href="https://matrix.to/#/#jellyfin-dev-client:matrix.org"><img alt="jellyfin-dev-client" src="https://img.shields.io/matrix/jellyfin-dev-client:matrix.org.svg?logo=matrix&label=jellyfin-dev-client"/></a>: Client and Web development
* <a href="https://matrix.to/#/#jellyfin-dev-android:matrix.org"><img alt="jellyfin-dev-android" src="https://img.shields.io/matrix/jellyfin-dev-android:matrix.org.svg?logo=matrix&label=jellyfin-dev-android"/></a>: Android, Android TV and Fire TV development
* <a href="https://matrix.to/#/#jellyfin-offtopic:matrix.org"><img alt="jellyfin-offtopic" src="https://img.shields.io/matrix/jellyfin-offtopic:matrix.org.svg?logo=matrix&label=jellyfin-offtopic"/></a>: Chat about anything
## IRC Channels
Some channels are bridged from Matrix to IRC on [Freenode](https://freenode.net) for convenience.
* [#jellyfin](ircs://chat.freenode.net:6697/#jellyfin) - [Webchat](https://webchat.freenode.net/#jellyfin)
* [#jellyfin-dev](ircs://chat.freenode.net:6697/#jellyfin-dev) - [Webchat](https://webchat.freenode.net/#jellyfin-dev)