Official NixOS Wiki

Jellyfin: Difference between revisions

← Older edit
RossSmyth (talk | contribs)
5 edits
VisualWikitext
Sandro (talk | contribs)
83 edits
→NVENC: Add blurb on the Nvidia support matrix.
 
(33 intermediate revisions by 21 users not shown)
Line 1: Line 1:
Jellyfin is the volunteer-built media solution that puts you in control of your media. Stream to any device from your own server, with no strings attached.
<languages/>


== Installing & Initial Configuration & Setup ==
{{infobox application
  |name=Jellyfin
  |image=Jelly-banner-light.svg
  |type=Media server
  |developer=Jellyfin Project
  |license=[https://www.gnu.org/licenses/gpl-2.0.html GPL-2.0]
  |os=Cross-platform (Linux, macOS, Windows)
  |platform=Server
  |programmingLanguage=C#
  |website=[https://jellyfin.org/ jellyfin.org]
  |github=jellyfin/jellyfin
  |bugTracker=[https://github.com/jellyfin/jellyfin/issues GitHub Issues]
  |documentation=[https://jellyfin.org/docs/ jellyfin.org/docs]
}}
<translate>
<!--T:1-->
<strong>[https://jellyfin.org/ Jellyfin]</strong><ref name="jellyfin">Jellyfin Project, "Jellyfin: The Free Software Media System", Official Website, Accessed October 2025. https://jellyfin.org/</ref> is a free and open-source media server that enables users to manage and stream their personal media libraries across various devices. It consists of the Jellyfin Server and multiple client applications including Jellyfin Media Player and a web interface.


To get up and running with Jellyfin, add the packages <code>pkgs.jellyfin</code> <code>pkgs.jellyfin-web</code> & <code>pkgs.jellyfin-ffmpeg</code> to your `configuration.nix` file as shown below.
== Client Installation ==


<syntaxHighlight lang=nix>
Jellyfin is available both via the web interface, and through a desktop application.
{
 
  services.jellyfin.enable = true;
If you would like to install the desktop application, use the following:
 
 
{{Warning|1=Currently in NixOS 25.11, jellyfin-desktop 2.0 on nixpkgs is unsupported (and no longer available on their [https://github.com/jellyfin/jellyfin-desktop/releases release page]) as it relies on an out-of-date QT engine. This can cause '''rapid, bright flashes''' when playing video on Wayland, which is a '''serious seizure risk''' (see [https://github.com/jellyfin/jellyfin-desktop/issues/127 this issue]).
 
The easiest fixes are:
* Use the web player.
* Run from the CLI with: `QT_QPA_PLATFORM=xcb jellyfin-desktop > /dev/null 2>&1 & disown`
* Create a launch script your app launcher can find [https://docs.vicinae.com/install/script as explained for vicinae here].}}
 
 
{{code|lang=nix|line=no|1={
   environment.systemPackages = [
   environment.systemPackages = [
    pkgs.jellyfin
     pkgs.jellyfin-desktop
     pkgs.jellyfin-web
    pkgs.jellyfin-ffmpeg
   ];
   ];
}
}
</syntaxHighlight>
}}
 
Alternatively, you can use the Jellyfin web client by using your preferred web browser to visit the server directly. See below on how to install the Jellyfin server.
 
== Server Installation == <!--T:2-->
 
<!--T:3-->
To enable Jellyfin on NixOS, add the service configuration to your <code>/etc/nixos/configuration.nix</code> file:
</translate>
 
{{code|lang=nix|line=no|1={
  services.jellyfin.enable = true;
}
}}


If you want more advanced configuration, use something like what's shown below and [https://search.nixos.org/options?query=jellyfin see the docs for more configuration options]
<translate>
<!--T:4-->
For more advanced configuration options, refer to the [https://search.nixos.org/options?query=jellyfin NixOS options documentation]:<ref name="nixos-options">NixOS Wiki contributors, "Jellyfin NixOS module options", NixOS Search, Accessed October 2025. https://search.nixos.org/options?query=jellyfin</ref>
</translate>


<syntaxHighlight lang=nix>
{{code|lang=nix|line=no|1={
{
   services.jellyfin = {
   services.jellyfin = {
     enable = true;
     enable = true;
Line 25: Line 65:
   };
   };
}
}
</syntaxHighlight>
}}
 
<translate>
<!--T:5-->
After configuring Jellyfin, rebuild your system for the changes to take effect:
</translate>


Once you have included the correct packages to be installed, and enabled and configured Jellyfin to your liking, then rebuild your system for changes to take effect.
{{code|lang=bash|line=no|$ sudo nixos-rebuild switch}}
<syntaxHighlight lang=bash>$ sudo nixos-rebuild switch</syntaxHighlight>


After the rebuild is complete Jellyfin should be running, verify that it is with the following command.
<translate>
<syntaxHighlight lang=bash>$ sudo systemctl status jellyfin</syntaxHighlight>
<!--T:6-->
After the rebuild completes, verify that Jellyfin is running:
</translate>


<b>If jellyfin is not running</b> you should be able to start it by simply running <code>jellyfin</code> in your terminal.
{{code|lang=bash|line=no|$ sudo systemctl status jellyfin}}
<syntaxHighlight lang=bash>$ jellyfin</syntaxHighlight>


Finally. After you've verified that Jellyfin is running you can start the configuration process.
<translate>
* The Jellyfin server should be running on port 8096.
<!--T:7-->
* Go to http://localhost:8096 if your setting this up on your primary computer or want to test your build locally.
If Jellyfin is not running, you can start it manually:
* If you're logging into a remote server, replace localhost with the ip address of the server.
</translate>


=== Allow Jellyfin to read external drives ===
{{code|lang=bash|line=no|$ jellyfin}}


You might encounter permission issues when you try to access external drives if you haven't configured anything else with the server yet. If you haven't explicitly set up a mounting configuration for your drives and instead have your desktop environment (e.g. GNOME or KDE) automatically mount it when you try accessing it via their file explorers, Jellyfin won't be able to access the drive. This is because the desktop environment mounts it to your user, while Jellyfin uses by default the "jellyfin" user.
<translate>
<!--T:8-->
Once Jellyfin is running, you can access the web interface:


The easiest way to allow it to see these external drives mounted is to change the service's user . Here is an example:
<!--T:9-->
<syntaxhighlight lang="nix">
* The Jellyfin server runs on port 8096 by default.<ref name="jellyfin-ports">Jellyfin Documentation Team, "Networking", Jellyfin Documentation, Accessed October 2025. https://jellyfin.org/docs/general/networking/</ref>
* Navigate to <code>http://localhost:8096</code> for local access.
* For remote access, replace <code>localhost</code> with the server's IP address.
 
== Configuration == <!--T:10-->
 
=== Allowing access to external drives === <!--T:11-->
 
<!--T:12-->
Desktop environments typically mount external drives for the current user, while Jellyfin runs as the system user <code>jellyfin</code> by default. This can cause permission issues when accessing external media.
 
<!--T:13-->
The simplest solution is to change the service user:
</translate>
 
{{code|lang=nix|line=no|1={
   services.jellyfin = {
   services.jellyfin = {
     enable = true;
     enable = true;
     openFirewall = true;
     openFirewall = true;
     user="yourusername";
     user = "yourusername";
   };
   };
</syntaxhighlight>
}
}}
 
<translate>
<!--T:14-->
If you change the user after Jellyfin is already installed, update the ownership of the data and cache directories:
</translate>
 
{{code|lang=bash|line=no|$ sudo chown -R yourusername:yourusername /var/lib/jellyfin
$ sudo chown -R yourusername:yourusername /var/cache/jellyfin}}


If you have changed the user option after you have already installed Jellyfin, you have to change the permissions of the folder /var/lib/jellyfin via chown to the user you set it to by doing this:
<translate>
<syntaxhighlight lang="nix">
<!--T:15-->
  sudo chown -R /var/lib/jellyfin
Then restart the service:
</syntaxhighlight>
</translate>


The alternative to this is to explicitly mount the drives via [[Filesystems]], but takes more effort to set up and requires every new drive you want plex to see to be explicitly declared, but allows more control in what Plex is allowed to see.
{{code|lang=bash|line=no|$ sudo systemctl restart jellyfin}}


=== Intro Skipper plugin ===
<translate>
If you install intro skipper plugin, it will not be able to display skip button in web interface. This is due to the plugin being unable to modify contents of files in nix store. To get around this you can make the changes yourself with this:  
<!--T:16-->
<syntaxhighlight lang="nix">
Alternatively, configure explicit mounts via [[Filesystems]]. This approach requires more setup and each drive must be declared, but provides finer control over what Jellyfin can access.
  nixpkgs.overlays = with pkgs; [
    (
      final: prev:
        {
          jellyfin-web = prev.jellyfin-web.overrideAttrs (finalAttrs: previousAttrs: {
            installPhase = ''
              runHook preInstall


              # this is the important line
=== Hardware transcoding === <!--T:17-->
              sed -i "s#</head>#<script src=\"configurationpage?name=skip-intro-button.js\"></script></head>#" dist/index.html


              mkdir -p $out/share
<!--T:18-->
              cp -a dist $out/share/jellyfin-web
Modern hardware often includes video acceleration capabilities that can significantly reduce CPU usage during transcoding. For detailed information, see the [https://jellyfin.org/docs/general/post-install/transcoding/hardware-acceleration/ official Jellyfin documentation].<ref name="jellyfin-hw">Jellyfin Documentation Team, "Hardware acceleration", Jellyfin Documentation, Accessed October 2025. https://jellyfin.org/docs/general/post-install/transcoding/hardware-acceleration/</ref>


              runHook postInstall
==== GPU Identification ====
            '';
 
          });
If a computer with multiple GPUs is being configured, such as a laptop with a discrete GPU, selecting the correct GPU by path may be difficult. The paths in question are at <code>/dev/dri</code>. There will be several entries within this directory:
        }
 
    )
* <code>/dev/dri/card*</code>
  ];
: 2D graphics accelerators, these are not relevant to Jellyfin.
* <code>/dev/dri/renderD*</code>
: 3D graphics accelerators. These are what Jellyfin uses. Often <code>/dev/dri/renderD128</code> and sequentially increasing from there.
* <code>/dev/dri/by-path</code>
: A directory that contains symlinks to the above devices, but with their PCI bus IDs. This will be used for identification.


</syntaxhighlight>
To identify, run <code>lspci</code>. This will most likely need to be downloaded, and is included in the package [https://search.nixos.org/packages?channel=unstable&query=lspci#show=pciutils pciutils]. This will show all devices on the PCI bus. For example:


== Hardware Transcoding ==
{{code|lang=text|line=no|
In most cases you want to make most of your hardware. Modern boards often come with Hardware Accelerators, all you need to do is enable it!
00:00.0 Host bridge: Intel Corporation Xeon E3-1200 v6/7th Gen Core Processor Host Bridge/DRAM Registers (rev 05)
00:01.0 PCI bridge: Intel Corporation 6th-10th Gen Core Processor PCIe Controller (x16) (rev 05)
00:02.0 VGA compatible controller: Intel Corporation Kaby Lake-H GT2 [HD Graphics 630] (rev 04)
00:14.0 USB controller: Intel Corporation 100 Series/C230 Series Chipset Family USB 3.0 xHCI Controller (rev 31)
00:14.2 Signal processing controller: Intel Corporation 100 Series/C230 Series Chipset Family Thermal Subsystem (rev 31)
00:15.0 Signal processing controller: Intel Corporation 100 Series/C230 Series Chipset Family Serial IO I2C Controller #0 (rev 31)
00:15.1 Signal processing controller: Intel Corporation 100 Series/C230 Series Chipset Family Serial IO I2C Controller #1 (rev 31)
00:16.0 Communication controller: Intel Corporation 100 Series/C230 Series Chipset Family MEI Controller #1 (rev 31)
00:17.0 SATA controller: Intel Corporation HM170/QM170 Chipset SATA Controller [AHCI Mode] (rev 31)
00:1c.0 PCI bridge: Intel Corporation 100 Series/C230 Series Chipset Family PCI Express Root Port #3 (rev f1)
00:1c.3 PCI bridge: Intel Corporation 100 Series/C230 Series Chipset Family PCI Express Root Port #4 (rev f1)
00:1f.0 ISA bridge: Intel Corporation HM175 Chipset LPC/eSPI Controller (rev 31)
00:1f.2 Memory controller: Intel Corporation 100 Series/C230 Series Chipset Family Power Management Controller (rev 31)
00:1f.3 Audio device: Intel Corporation HM175/QM175/CM238 HD Audio Controller (rev 31)
00:1f.4 SMBus: Intel Corporation 100 Series/C230 Series Chipset Family SMBus (rev 31)
01:00.0 VGA compatible controller: NVIDIA Corporation GP106M [GeForce GTX 1060 Mobile] (rev a1)
01:00.1 Audio device: NVIDIA Corporation GP106 High Definition Audio Controller (rev a1)
02:00.0 Network controller: Qualcomm Atheros QCA6174 802.11ac Wireless Network Adapter (rev 32)
03:00.0 Unassigned class [ff00]: Realtek Semiconductor Co., Ltd. RTL8411B PCI Express Card Reader (rev 01)
03:00.1 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL8111/8168/8211/8411 PCI Express Gigabit Ethernet Controller (rev 12)
}}


Source: https://jellyfin.org/docs/general/administration/hardware-acceleration.html
The beginning of each line denotes the device's PCI bus ID. Note this for the GPU desired, and add this device to your Jellyfin configuration via the <code>/dev/dri/by-path</code> directory. In this example, the Nvidia 1060M is added to the config. It can also be added to the config by inspecting the <code>by-path</code> symlink with <code>realpath</code> and using the canonical path.  


=== VAAPI and Intel QSV ===
{{code|1={
  services.jellyfin = {
    enable = true;
    hardwareAcceleration = {
      enable = true;
      type = "nvenc";
      device = "/dev/dri/by-path/pci-0000:01:00.0-render";
    };
}|lang=nix}}


VAAPI and QSV is often available on platforms with Intel GPUs but need their corresponding packages in <code>hardware.graphics.extraPackages</code>.
==== NVENC ====
Nvidia GPU's use NVENC for hardware encoding. To use this, CUDA must be enabled:
{{Code|1={
  nix.settings = {
    substituters = [
      "https://cache.flox.dev"
    ];
    trusted-public-keys = [
      "flox-cache-public-1:7F4OyH7ZCnFhcze3fJdfyXYLQw/aV7GEed86nQ7IsOs="
    ];
  };
  nixpkgs.config.cudaSupport = true;


<syntaxHighlight lang=nix>
  services.jellyfin = {
{ pkgs, lib,config, ... }:
    enable = true;
    hardwareAcceleration = {
      enable = true;
      type = "nvenc";
      device = "/dev/dri/renderD128";
    };
  };
}|lang=nix}}For configuring the <code>services.jellyfin.transcoding.hardwareDecodingCodec</code> and <code>services.jellyfin.transcoding.hardwareDecodingCodec</code> options for Nvidia GPUs, [https://developer.nvidia.com/video-encode-decode-support-matrix consult the support matrix provided by Nvidia]
 
==== VAAPI and Intel QSV ==== <!--T:19-->
 
<!--T:20-->
Intel GPUs support Video Acceleration API (VAAPI) and Quick Sync Video (QSV). The required packages must be added to <code>hardware.graphics.extraPackages</code>.
 
<!--T:21-->
Choose the appropriate driver based on your CPU generation:
* <code>intel-vaapi-driver</code> for pre-Broadwell CPUs
* <code>intel-media-driver</code> for Broadwell and newer
* <code>intel-compute-runtime</code> for newer processors
</translate>
 
{{Note|<translate><code>intel-media-sdk</code> is deprecated and does not build on recent channels. Use VAAPI with <code>intel-media-driver</code> instead. See [https://discourse.nixos.org/t/intel-media-sdk-has-become-deprecated/66998 this discussion] for details.<ref name="intel-media-sdk">smana, "intel-media-sdk has become deprecated", NixOS Discourse, Accessed October 2025. https://discourse.nixos.org/t/intel-media-sdk-has-become-deprecated/66998</ref></translate>}}
 
{{code|lang=nix|line=no|1=
{ pkgs, lib, config, ... }:
{
{
   # 1. enable vaapi on OS-level
   # Only set this if using intel-vaapi-driver:
   nixpkgs.config.packageOverrides = pkgs: {
   nixpkgs.config.packageOverrides = pkgs: {
     vaapiIntel = pkgs.vaapiIntel.override { enableHybridCodec = true; };
     intel-vaapi-driver = pkgs.intel-vaapi-driver.override { enableHybridCodec = true; };
   };
   };
   hardware.graphics = { # hardware.opengl in 24.05
 
  systemd.services.jellyfin.environment.LIBVA_DRIVER_NAME = "iHD"; # or i965 for older GPUs
  environment.sessionVariables = { LIBVA_DRIVER_NAME = "iHD"; };
 
   hardware.graphics = {
     enable = true;
     enable = true;
     extraPackages = with pkgs; [
     extraPackages = with pkgs; [
      intel-ocl # Generic OpenCL support
      # For Broadwell and newer (ca. 2014+), use with LIBVA_DRIVER_NAME=iHD:
       intel-media-driver
       intel-media-driver
       intel-vaapi-driver # previously vaapiIntel
 
       vaapiVdpau
      # For older processors, use with LIBVA_DRIVER_NAME=i965:
       intel-compute-runtime # OpenCL filter support (hardware tonemapping and subtitle burn-in)
       intel-vaapi-driver
       vpl-gpu-rt # QSV on 11th gen or newer
      libva-vdpau-driver
       intel-media-sdk # QSV up to 11th gen
 
      # For 13th gen and newer:
      intel-compute-runtime
 
       # For older processors:
       intel-compute-runtime-legacy1
 
      # For 11th gen and newer:
       vpl-gpu-rt
 
      # Deprecated (may not build on recent channels):
       # intel-media-sdk
     ];
     ];
   };
   };


  # 2. do not forget to enable jellyfin
   services.jellyfin.enable = true;
   services.jellyfin.enable = true;
}
}
</syntaxHighlight>
}}
 
<translate>
==== Troubleshooting VAAPI and Intel QSV ==== <!--T:22-->
 
<!--T:23-->
Check supported VAAPI profiles:
</translate>
 
{{code|lang=bash|line=no|$ nix-shell -p libva-utils --run vainfo}}
 
<translate>
<!--T:24-->
Verify OpenCL availability:
</translate>
 
{{code|lang=bash|line=no|$ nix-shell -p clinfo --run clinfo}}
 
<translate>
<!--T:25-->
If <code>clinfo</code> shows <code>Number of platforms 0</code>, OpenCL is not enabled or available.
 
<!--T:26-->
Monitor Intel GPU status:
</translate>
 
{{code|lang=bash|line=no|$ nix-shell -p intel-gpu-tools --run intel_gpu_top}}
 
<translate>
<!--T:27-->
On Intel N100 CPUs, enable firmware loading to prevent GuC errors:
</translate>
 
{{code|lang=nix|line=no|1={
  hardware.enableAllFirmware = true;
}
}}
 
<translate>
<!--T:28-->
Without this option, you may see errors like:
</translate>
 
{{code|lang=text|line=no|[    4.174843] i915 0000:00:10.0: [drm] *ERROR* GT0: GuC firmware i915/tgl_guc_70.bin: fetch failed -ENOENT
[    4.175621] i915 0000:00:10.0: [drm] GT0: GuC firmware(s) can be downloaded from https://git.kernel.org/pub/scm/linux/kernel/git/firmware/linux-firmware.git/tree/i915
[    4.176350] i915 0000:00:10.0: [drm] *ERROR* GT0: GuC initialization failed -ENOENT
[    4.176977] i915 0000:00:10.0: [drm] *ERROR* GT0: Enabling uc failed (-5)
[    4.177502] i915 0000:00:10.0: [drm] *ERROR* GT0: Failed to initialize GPU, declaring it wedged!}}
 
<translate>
==== VAAPI and Intel QSV on Arc GPU ==== <!--T:29-->
 
<!--T:30-->
Arc GPUs require Jellyfin to use FFmpeg compiled with <code>vpl</code> support. Use [[Overlays|an overlay]] to override the FFmpeg configuration:
</translate>
 
{{code|lang=nix|line=no|1=
{ pkgs, ... }:
let
  jellyfin-ffmpeg-overlay = (final: prev: {
    jellyfin-ffmpeg = prev.jellyfin-ffmpeg.override {
      # Exact version depends on jellyfin-ffmpeg package
      # In 24.11 it's ffmpeg_7-full
      ffmpeg_7-full = prev.ffmpeg_7-full.override {
        withMfx = false; # Older media driver
        withVpl = true;  # New driver for Arc GPUs
        withUnfree = true;
      };
    };
  });
in
{
  nixpkgs.overlays = [ jellyfin-ffmpeg-overlay ];
}
}}
 
<translate>
<!--T:31-->
This triggers a rebuild of the Jellyfin package. After applying, select "Intel QuickSync (QSV)" in the Jellyfin settings for hardware-accelerated transcoding with minimal CPU load.
 
On NixOS 25.11 and newer (specifically since [https://github.com/NixOS/nixpkgs/pull/424061 this PR]), <code>vpl</code> support in FFmpeg is enabled by default, so there is no need to use an overlay.
 
<!--T:32-->
If your system has both integrated and discrete GPUs, manually select the QSV device in the Playback settings to avoid random device selection. Use <code>intel_gpu_top -L</code> to list available devices.
 
==== VAAPI with Jellyfin in a NixOS container ==== <!--T:33-->
 
<!--T:34-->
Containers do not inherit graphics drivers from the host system. When running Jellyfin in a NixOS container, replicate the <code>hardware.graphics</code> configuration and pass through the GPU devices (typically <code>/dev/dri/card0</code> and <code>/dev/dri/renderD128</code>):
</translate>
 
{{code|lang=nix|line=no|1=
{
  allowedDevices = [
    { node = "/dev/dri/card0"; modifier = "rw"; }
    { node = "/dev/dri/renderD128"; modifier = "rw"; }
  ];
 
  bindMounts = {
    "/dev/dri/card0" = {
      hostPath = "/dev/dri/card0";
      isReadOnly = false;
    };
    "/dev/dri/renderD128" = {
      hostPath = "/dev/dri/renderD128";
      isReadOnly = false;
    };
  };
 
  config = {
    # Include hardware.graphics and services.jellyfin configuration
  };
}
}}
 
<translate>
<!--T:35-->
Verify the configuration by adding <code>libva-utils</code> to the container's <code>environment.systemPackages</code>, logging in with <code>machinectl shell container-name</code>, and running <code>vainfo</code>. Successful output looks like:
</translate>
 
{{code|lang=text|line=no|Trying display: drm
libva info: VA-API version 1.22.0
libva info: Trying to open /run/opengl-driver/lib/dri/iHD_drv_video.so
libva info: Found init function __vaDriverInit_1_22
libva info: va_openDriver() returns 0
vainfo: VA-API version: 1.22 (libva 2.22.0)
vainfo: Driver version: Intel iHD driver for Intel(R) Gen Graphics - 25.2.6 ()
vainfo: Supported profile and entrypoints
      VAProfileNone                  : VAEntrypointVideoProc
      VAProfileNone                  : VAEntrypointStats
      /* Additional profiles depend on your hardware */}}
 
<translate>
<!--T:36-->
With correct configuration, FFmpeg and Jellyfin can use hardware transcoding.
 
== Tips and tricks == <!--T:37-->
 
=== Intro Skipper plugin === <!--T:38-->
 
<!--T:39-->
The latest version of the Intro Skipper plugin from [https://github.com/intro-skipper/intro-skipper GitHub]<ref name="intro-skipper">Intro Skipper contributors, "Intro Skipper Jellyfin plugin", GitHub, Accessed October 2025. https://github.com/intro-skipper/intro-skipper</ref> works without manual patches on Jellyfin web, Jellyfin Media Player, and Android TV clients.
 
<!--T:40-->
If you need to manually patch the web interface for older versions, use an overlay:
</translate>
 
{{code|lang=nix|line=no|1=
nixpkgs.overlays = [
  (final: prev: {
    jellyfin-web = prev.jellyfin-web.overrideAttrs (finalAttrs: previousAttrs: {
      installPhase = ''
        runHook preInstall
        sed -i "s#</head>#<script src=\"configurationpage?name=skip-intro-button.js\"></script></head>#" dist/index.html
        mkdir -p $out/share
        cp -a dist $out/share/jellyfin-web
        runHook postInstall
      '';
    });
  })
];
}}
 
<translate>
== Troubleshooting == <!--T:41-->
 
=== Service not starting === <!--T:42-->
 
<!--T:43-->
If Jellyfin fails to start, check the service status:
</translate>
 
{{code|lang=bash|line=no|$ sudo systemctl status jellyfin}}
 
<translate>
<!--T:44-->
Review the service logs for error messages:
</translate>
 
{{code|lang=bash|line=no|$ sudo journalctl -u jellyfin -n 50}}
 
<translate>
=== Cannot access media files === <!--T:45-->
 
<!--T:46-->
Verify that the Jellyfin user has read permissions for your media directories. Check file ownership and permissions:
</translate>
 
{{code|lang=bash|line=no|$ ls -la /path/to/media}}
 
<translate>
<!--T:47-->
If using a custom user for the Jellyfin service, ensure the data directories have correct ownership as described in the configuration section.
 
== See also == <!--T:48-->
 
<!--T:49-->
* [[Filesystems]] – Declarative filesystem mounting on NixOS
* [[Accelerated Video Playback]] – GPU acceleration configuration
* [[Intel Graphics]] – Intel GPU driver setup
* [[Overlays]] – Customizing packages with overlays
* [https://search.nixos.org/options?query=jellyfin NixOS options search] – Jellyfin module options
* [https://jellyfin.org/docs/ Jellyfin documentation] – Official Jellyfin documentation
 
== References == <!--T:50-->
</translate>


Related:  [[Accelerated_Video_Playback]] [[Intel_Graphics]]
<references/>


[[Category:Server]]
[[Category:Server]]
[[Category:Applications]]
[[Category:Applications]]
[[Category:Web Applications]]
Retrieved from "https://wiki.nixos.org/wiki/Jellyfin"