The Jellyfin YouTube metadata plugin depends on a file naming convention

A metadata provider for YouTube sourced libraries

The plugin is described as a plugin for Jellyfin that retrieves metadata for content from Youtube. The supported library types are Movies, Music Videos and Shows, and it supports thumbnails in jpg or webp format for both channels and videos, plus ExternalID providing quick links to the source of the metadata. That last item is the difference between a scraped copy and a pointer, since an ExternalID lets Jellyfin and the viewer jump back to where the video actually lives. The implementation is a C# solution named `Jellyfin.Plugin.YoutubeMetadata.sln`, with the plugin itself in `Jellyfin.Plugin.YoutubeMetadata/` and its tests in `Jellyfin.Plugin.YoutubeMetadata.Providers.Tests/`.

Two providers: local files or yt-dlp on demand

The design is split into two providers, and the choice between them is a real trade-off rather than a setting with a right answer. The local provider uses the `info.json` files provided from yt-dlp or similar programs, which means the metadata is already on your disk and nothing is fetched at scan time. The remote provider uses yt-dlp to download the `info.json` files, which means the metadata arrives when Jellyfin asks for it and the download tool has to be reachable. The requirements section is explicit that yt-dlp is required if you are using the remote provider, and the installation prerequisites repeat it, saying you are required to have yt-dlp available on the system or the container Jellyfin is running on.

The bracket naming rule is the whole join

How the plugin knows which metadata belongs to which file is the part to understand before anything else. The usage section says all media needs to have the ID embedded in the file name within square brackets, and gives two valid examples, a channel file named `3Blue1Brown - NA - 3Blue1Brown_-_Videos [UCYO_jab_esuFRV4b17AJtAw].info.json` and a video file named `3Blue1Brown - 20211023 - A_few_of_the_best_math_explainers_from_this_summer [F3Qixy-r_rQ].mkv`. The `info.json` and image files need to have the same file name as the media file, and the README shows what breaks when they do not, with a video named with the full title and an info file named without it. The proper naming format is the default when using yt-dlp and is also enforced in the YouTube-DL scripts collection the author recommends.

Installing through the plugin repository

The recommended route goes through the Admin Dashboard rather than a file copy. You go to the Admin Dashboard, then in the left navigation menu you click on `Plugins`, then in the top menu you click `Repositories`, and then you click the `+` icon to add a new repository. The repository name can be anything, but the URL must be the manifest published in the author's plugin repository:

https://raw.githubusercontent.com/ankenyr/jellyfin-plugin-repo/master/manifest.json

If that is done correctly you should see a new repository on the page, and then in the top menu you navigate to `Catalog`, and under the `Metadata` section you click on `YoutubeMetadata` and then `Install`. You restart Jellyfin, click on `Plugins` in the left navigation, and if it worked you see `YoutubeMetadata` with a status of `Active`. The manifest indirection matters because it is how the plugin updates itself, so pinning to a git URL instead would lose that path.

Manual installation, and why it is labelled hard

There is a fallback for a Jellyfin instance that cannot reach the repository manifest. You navigate to the releases page, download the latest zip file, unzip the contents into `<jellyfin data directory>/plugins/YoutubeMetadata`, restart Jellyfin, and then check the `Plugins` page for `YoutubeMetadata` with a status of `Active`. The README calls this path manual installation and marks it hard. The reason is visible in the structure: the plugin is registered with Jellyfin's plugin system at startup, so the directory layout, the assembly version and the Jellyfin version have to agree, and there is no manifest to negotiate that for you. For a container deployment, the plugin directory is a volume mount, so the same step applies with an extra path to get right.

Getting yt-dlp next to Jellyfin

Three ways are given, and the README says they are examples rather than an exhaustive list. From a package manager, the APT command is `sudo apt-get install yt-dlp`, and Nix has a package of the same name. Inside a container you exec into it and fetch the binary directly:

docker exec -it -u root jellyfin bash
curl -L https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp -o /bin/yt-dlp
chmod a+rx /bin/yt-dlp
apt update && apt install --no-install-recommends --no-install-suggests python3

If you build your own image, the dependency is a pip install on top of a Jellyfin base image:

FROM linuxserver/jellyfin:nightly
RUN apt-get update && apt-get install -y \
    python3-pip
RUN python3 -m pip install -U yt-dlp

The `python3` install in the container path is the step people miss when following the README's container example.

Cookies, enabling the provider, and the state of the project

Enabling the provider is a per library step. You navigate to the Admin Dashboard, click `Libraries` in the left navigation, click the three dots for a supported library type, click `Manage library`, tick the checkbox next to `YoutubeMetadata` for each downloader or fetcher you want to enable, click `OK`, and then click `Scan All Libraries`. Cookies are an optional extra with a clear warning. Placing a file named `cookies.txt` into the plugin directory enables yt-dlp to use your cookie, and the README warns that your cookie grants access to the accounts it is granted for and that the file should be protected. The licence is AGPL-3.0, which is a network copyleft licence and the part to check if you intend to modify and redistribute the plugin. The releases are versioned v1.0.3.14 and v1.0.3.15 from January and February 2026, with the last push to the repository on 2026-05-05, and the project accepts donations through Ko-fi.

Editorial conclusion

Adopt this plugin when your Jellyfin library holds YouTube content downloaded with yt-dlp and the metadata never made it into Jellyfin, since the plugin reads the info.json files already on disk or fetches them for you. Do not adopt it for a library whose naming does not follow the bracket convention, because the join between a media file and its metadata is the ID in the file name and nothing else. Verify first that yt-dlp is reachable from the Jellyfin process, whether that is the host or the container, since the remote provider shells out to it, and decide how you will handle cookies before you point the plugin at a channel that needs an account.

Frequently asked questions

Official sources

1. ankenyr/jellyfin-youtube-metadata-plugin on GitHub
2. Issues
3. License: AGPL-3.0
4. README
5. Releases