Jellyfin Naming Guide: Movies, TV Shows, Anime, Music & Plex Migration (2026)

Jellyfin Naming Fundamentals

Jellyfin's scanner architecture is different from Plex's, and understanding the difference avoids three quarters of the "Jellyfin won't match my files" frustration. The good news: most Plex-compatible naming works in Jellyfin out of the box. The catch: Jellyfin's flexibility means you can write valid naming patterns that work for one library and fail for another depending on the providers you've enabled.

Open source, scanner built in

Jellyfin is open source, self-hosted, and free forever — no premium tier, no telemetry, no plugin paywall. The scanner is part of the server itself, not a separate plugin like Plex's. This means Jellyfin updates ship naming improvements through the regular release cycle (currently monthly-ish), and you can read the exact parsing code on GitHub if a pattern surprises you. The trade-off vs Plex: Jellyfin's metadata UI is rougher around the edges, the hardware acceleration setup is more manual, and a few Plex features (Plex Pass DVR, Plexamp's sonic analysis) have no direct equivalent. For naming purposes none of this matters — you get the same TMDB, TVDB, AniDB, MusicBrainz, OMDb pipelines Plex uses, just configured differently.

Metadata providers (not "agents")

Where Plex has "agents", Jellyfin has "metadata providers" configured per library. When you create a library, you pick which providers to query and in what order. For movies the default is TheMovieDB; you can add OMDb, TVDb, or none. For TV shows it's TheMovieDB and TheTVDB, with The Open Movie Database (OMDb) as a fallback. For anime you can add AniDB and AniList directly (no HAMA-style external plugin needed). The provider order matters: Jellyfin queries them top-to-bottom and uses the first successful match. If TheMovieDB returns the wrong show because of a title collision, putting TheTVDB first might fix it. This per-library config is more powerful than Plex's hardcoded agent choice — and it's the secret to making anime work without third-party scanners.

Four rules that fix most matching failures

Four rules that prevent the vast majority of Jellyfin matching problems: Rule 1 — Use a folder-per-item structure. Movies in their own folders, TV shows with explicit season subfolders. Jellyfin scans the folder tree to understand item boundaries before reading filenames. Rule 2 — Include the release year in parentheses for movies, just like Plex: "Title (YYYY)". Jellyfin's matcher uses the year identically to Plex's. Rule 3 — Use the sXXeYY pattern for episodes. Jellyfin accepts more variations than Plex (the docs list 8+ valid formats), but lowercase zero-padded sXXeYY is the safest and most readable. Rule 4 — When in doubt, embed the provider ID in the folder name. Jellyfin supports "[tmdbid-12345]", "[tvdbid-67890]", "[imdbid-tt1234567]" suffixes that force exact matches. Use them whenever a title is ambiguous.

Need it from zero? step-by-step renaming.

Naming Movies for Jellyfin

Movies are the simplest Jellyfin media type. The folder-per-movie pattern matches Plex's; the year is mandatory for disambiguation; multi-version files are supported through a slightly different naming convention than Plex's. Three minor differences are all you need to remember if you're coming from Plex.

Folder structure

Each movie lives in its own folder, named "Title (Year)". The video file inside repeats that exact name. Subtitles, extras, posters, and trailers live alongside.

Movies/
├── Blade Runner (1982)/
│   ├── Blade Runner (1982).mkv
│   ├── Blade Runner (1982).en.srt
│   ├── poster.jpg
│   └── trailers/
│       └── teaser.mp4
├── Dune (2021)/
│   └── Dune (2021).mkv
└── The Matrix (1999)/
    └── The Matrix (1999).mkv

Jellyfin reads the folder name first, then the filename. Keeping them identical is the cleanest pattern and lets you store extras and artwork without naming collisions.

The year is non-negotiable

The year is non-negotiable for the same reason as Plex: TheMovieDB returns duplicate-title matches ordered by popularity, and without the year you get whichever release is more famous on TMDB today. Format: "Title (YYYY)" with the year in parentheses. Jellyfin's regex is forgiving — it accepts "Title.YYYY.mkv" and "Title YYYY.mkv" — but those formats break when titles contain numbers ("2001: A Space Odyssey", "1917"). Parentheses are unambiguous. Use them always.

Multi-version movies

Jellyfin supports multiple versions of the same movie merged into a single library entry, similar to Plex but with a different naming pattern. The official Jellyfin convention uses dashes and version labels:

Dune (2021)/
├── Dune (2021) - 1080p.mkv
└── Dune (2021) - 2160p.mkv

Or the subfolder pattern, which works identically in Jellyfin and is cleaner for libraries with many edits:

Dune (2021)/
├── 1080p/
│   └── Dune (2021).mkv
└── 2160p/
    └── Dune (2021).mkv

Both files appear as a single movie card with a version picker. Jellyfin auto-selects the highest-quality file the client can play directly; if no client can play 4K HEVC, it falls back to the lower-resolution copy without transcoding.

Editions (Director's Cut, Theatrical, Extended)

For director's cuts, theatrical releases, and extended editions, Jellyfin supports the "[edition-X]" suffix pattern, which differs from Plex's "{edition-X}" curly-brace convention. Be careful when migrating — the curly-brace pattern is silently ignored by Jellyfin:

Movies/
├── Blade Runner (1982)/
│   ├── Blade Runner (1982) [edition-Theatrical].mkv
│   └── Blade Runner (1982) [edition-Final Cut].mkv
└── Apocalypse Now (1979)/
    ├── Apocalypse Now (1979) [edition-Theatrical].mkv
    └── Apocalypse Now (1979) [edition-Redux].mkv

Each edition shows up as its own movie in the library (not merged like multi-version). Use for cuts with meaningful runtime or content differences; use multi-version for the same cut at different resolutions.

Trailers, behind-the-scenes, and extras

Jellyfin treats extras (trailers, behind-the-scenes, deleted scenes, interviews) as first-class content. Place them in subfolders inside the movie folder using these exact names: `trailers/`, `behind the scenes/`, `deleted scenes/`, `interviews/`, `featurettes/`, `scenes/`, `shorts/`. Files inside these folders inherit the movie's metadata and appear in the Jellyfin player as related content.

Dune (2021)/
├── Dune (2021).mkv
├── trailers/
│   ├── trailer-1.mp4
│   └── trailer-2.mp4
└── behind the scenes/
    └── making-of.mp4

Same convention works for TV shows — extras at the show level go in extras subfolders at the show root.

Mistakes that account for most matching failures

The four mistakes that account for most movie matching failures in Jellyfin: 1. Using Plex's curly-brace edition syntax `{edition-X}`. Jellyfin ignores it silently — the suffix becomes part of the matched title, breaking the lookup. 2. Year missing on a non-unique title. "Inception.mkv" matches by sheer popularity; "Dune.mkv" picks Villeneuve's 2021 cut over the 1984 Lynch film 100% of the time on TMDB. 3. Single-file library at the root (no folder). Works for matching but breaks extras, posters, and multi-version support. 4. Wrong character encoding in non-Latin titles. Greek, Cyrillic, and Japanese title characters need UTF-8 filename encoding; some legacy zip extractors write Latin-1 instead.

Real-world examples

Movies/
├── The Matrix (1999)/
│   └── The Matrix (1999).mkv
├── Dune (2021)/
│   ├── Dune (2021) - 1080p.mkv
│   └── Dune (2021) - 2160p.mkv
├── Blade Runner (1982)/
│   ├── Blade Runner (1982) [edition-Theatrical].mkv
│   └── Blade Runner (1982) [edition-Final Cut].mkv
├── 1917 (2019)/
│   └── 1917 (2019).mkv
└── Spirited Away (2001)/
    ├── Spirited Away (2001).mkv
    └── trailers/
        └── trailer.mp4

Compare to Plex equivalents.

Official: Jellyfin movies docs · Jellyfin extras docs

Naming TV Shows for Jellyfin

TV is where Jellyfin's flexibility shines and trips up new users. Eight valid filename patterns are accepted by the scanner, which sounds great until you mix them in the same show folder and the matcher picks the wrong one. The fix is to pick one pattern and apply it consistently — sXXeYY lowercase being the only pattern that's universally safe.

Folder structure

Two levels: show folder, then season folder. Same as Plex. Jellyfin will not group episodes correctly if you flatten the structure.

TV Shows/
├── Breaking Bad (2008)/
│   ├── Season 01/
│   │   ├── Breaking Bad - s01e01 - Pilot.mkv
│   │   └── Breaking Bad - s01e02 - Cat's in the Bag.mkv
│   ├── Season 02/
│   │   └── Breaking Bad - s02e01.mkv
│   └── Specials/
│       └── Breaking Bad - s00e01 - Behind the Scenes.mkv
└── The Wire (2002)/
    └── Season 01/
        └── The Wire - s01e01.mkv

Show folder format: "Title (Year)". Year disambiguates remakes (The Office UK 2001 vs US 2005, House of Cards UK 1990 vs US 2013). Season folder format: "Season XX" zero-padded, or "Specials" for season 0.

Force a specific provider match

Bonus: append "[tmdbid-X]" or "[tvdbid-Y]" to the show folder name. Jellyfin uses this as the canonical lookup and ignores title-based matching:

The Office (2005) [tmdbid-2316]/
└── Season 01/
    └── The Office - s01e01.mkv

Filename pattern

Jellyfin's scanner accepts these episode patterns: - `Show - s01e01.mkv` (lowercase, recommended) - `Show - S01E01.mkv` (uppercase) - `Show - 1x01.mkv` (cross-style) - `Show.S01.E01.mkv` (dot-separated) - `Show s01e01 Title.mkv` (no dash) - `Show 101.mkv` (compact — risky) - `Show 1.01.mkv` (dot-compact — risky) - `Show Season 1 Episode 1.mkv` (verbose) Pick one and stick with it. The "compact" forms (Show 101) work but break on shows with 100+ episodes per season or three-digit absolute numbering. Lowercase sXXeYY is the safest universal pattern.

Breaking Bad - s05e14 - Ozymandias.mkv

You can add an episode title for human readability. The episode title is not used for matching — Jellyfin's metadata provider overrides it with the canonical title from TVDB/TMDB.

Specials, OVAs, and per-season extras

Specials, OVAs, behind-the-scenes episodes, and extras tied to a season go in a "Specials" folder at the show root, or in "Season 00". Jellyfin treats both identically. Inside, name files s00e01, s00e02, in order. Per-season extras (trailers, deleted scenes) can also live in extras subfolders inside their parent Season folder, using the same conventions as movie extras (`trailers/`, `deleted scenes/`, etc.).

Date-based daily shows

Daily shows (talk shows, news) without season/episode numbering use the date pattern:

The Daily Show (1996)/
└── Season 29/
    └── The Daily Show - 2024-03-15.mkv

YYYY-MM-DD format. Jellyfin matches against TheTVDB's date index for daily shows — make sure TheTVDB is enabled as a provider for the library.

Multi-episode files

For double-episodes in a single file:

Breaking Bad - s05e15-e16 - Granite State + Felina.mkv

Jellyfin creates one playable item that maps to both episodes in the metadata. The range form (`e15-e16`) is cleaner; the full-repeat form (`s05e15-s05e16`) also works.

Mini-series and limited series

Mini-series and limited series (Chernobyl, Band of Brothers, The Queen's Gambit) follow the standard pattern with "Season 01" as the only season folder. Don't flatten episodes into the show root — Jellyfin's scanner expects the season folder layer even for one-season shows.

The most common TV failures

The most common TV failures in Jellyfin and their causes: — "Episode unmatched" but the season is fine: filename pattern is malformed or mixes styles (s01E01 — uppercase E with lowercase s). Standardize to lowercase sXXeYY. — Whole season unmatched: season folder doesn't start with "Season " (note the space). "S1", "Season1", and "s01" don't match. — Wrong show matched: missing year on a title with collisions. Add `(YYYY)` to the show folder, or use `[tmdbid-X]` for absolute disambiguation. — Episodes split across wrong seasons: if you renamed files but Jellyfin still shows old assignments, force a metadata refresh from the show's ⋯ menu → "Refresh metadata" → "Replace all metadata" → "Force". — Special episodes appearing as season 1: file is in the show root instead of "Specials/" or "Season 00/" folder. Move the file. — Mini-series shown as a single big episode: all episodes are in the show root with no season folder. Add "Season 01/" and move the files in.

Real-world examples

TV Shows/
├── Breaking Bad (2008)/
│   ├── Season 01/
│   │   ├── Breaking Bad - s01e01 - Pilot.mkv
│   │   └── Breaking Bad - s01e02 - Cat's in the Bag.mkv
│   ├── Season 05/
│   │   └── Breaking Bad - s05e15-e16 - Granite State + Felina.mkv
│   └── Specials/
│       └── Breaking Bad - s00e01 - No Half Measures.mkv
├── The Office (2005) [tmdbid-2316]/
│   └── Season 03/
│       └── The Office - s03e12 - Back from Vacation.mkv
├── Chernobyl (2019)/
│   └── Season 01/
│       └── Chernobyl - s01e01 - 1:23:45.mkv
└── The Daily Show (1996)/
    └── Season 29/
        └── The Daily Show - 2024-03-15.mkv

Official: Jellyfin shows docs

Naming Anime for Jellyfin (Without HAMA)

This is where Jellyfin pulls ahead of Plex for most users. Plex requires the HAMA community plugin to handle AniDB properly — manual install, manual updates, breakable. Jellyfin ships AniDB and AniList as native metadata providers you enable from the library settings. No external scanners, no GitHub plugin folder, no plugin permissions to grant.

Native AniDB + AniList providers

For an anime library, create a new library of type "TV Shows" and in the metadata providers list: 1. AniDB — most accurate for absolute-numbered series (One Piece, Detective Conan, Bleach) 2. AniList — secondary, useful for modern shonen and seasonal anime 3. TheTVDB — fallback for series with strong English-dub releases 4. TheMovieDB — last resort, often wrong on anime Put AniDB first. Most Reddit "Jellyfin anime not matching" complaints trace back to TheMovieDB being prioritized by default.

For shows with title ambiguity (multiple anime sharing a name across decades), force the AniDB ID directly in the folder name:

Anime/
└── One Piece [anidbid-69]/
    └── Season 01/

Jellyfin reads `[anidbid-X]`, `[tvdbid-X]`, `[tmdbid-X]` from the folder name and uses them as the canonical lookup, skipping title-based fuzzy matching entirely. This is the closest Jellyfin equivalent to Plex's HAMA scanner — and it works out of the box.

Absolute numbering (One Piece, Naruto)

For absolute-numbered series (One Piece episode 1064, Naruto Shippuden episode 500), AniDB tracks everything as season 1 by default. Name files accordingly:

One Piece [anidbid-69]/
└── Season 01/
    ├── One Piece - s01e0001.mkv
    ├── One Piece - s01e0002.mkv
    └── One Piece - s01e1064.mkv

The four-digit padding (`e0001` instead of `e1`) isn't strictly required but keeps the filesystem sort order matching the playback order — handy when you browse the folder outside Jellyfin. If you want TVDB-style season splits (One Piece broken into 21+ arcs), drop the AniDB ID and let TheTVDB provider take over. Choose one model and stay consistent across the show.

Split seasons & cours (Attack on Titan, Demon Slayer)

Modern anime split into multiple "seasons" or "cours" (Attack on Titan Final Season Parts 1/2/3, Demon Slayer Mugen Train arc vs Entertainment District arc) are the most common source of "wrong season matched" issues. The fix is the same as Plex's: decide which database matches your mental model of the show, set the provider order accordingly, and use folder-level IDs to force matches:

Anime/
├── Attack on Titan [anidbid-9541]/
│   ├── Season 01/
│   ├── Season 02/
│   ├── Season 03/
│   └── Season 04/                    ← Final Season part 1
├── Attack on Titan - Final Season Part 2 [anidbid-15689]/
│   └── Season 01/                    ← split as its own AniDB entry
└── Demon Slayer (2019)/
    ├── Season 01/
    ├── Season 02/                    ← Mugen Train + Entertainment District
    └── Season 03/                    ← Swordsmith Village

OVAs and anime films

OVAs, anime films tied to a series, and specials all go in "Specials" or "Season 00" with sequential numbering. AniDB has rich metadata for these — most Plex-style "ambiguous OVA" cases resolve correctly in Jellyfin without extra config. For standalone anime films (Your Name, Spirited Away, Akira), put them in your Movies library, not an anime TV library. Jellyfin's anime provider handles films better than its TV provider does.

Sub vs dub

Like Plex, Jellyfin can store multiple audio tracks per file or store separate sub/dub files as multi-version siblings. The multi-version pattern lets viewers switch via the version picker:

Show - s01e01 - JPN.mkv
Show - s01e01 - ENG.mkv

Or use the resolution-suffix pattern with audio language:
Show - s01e01 - 1080p JPN.mkv
Show - s01e01 - 1080p ENG.mkv

Single-file with embedded multi-audio is cleaner — Jellyfin reads the audio language tags from the container and lets viewers pick a track in the player UI.

Real-world examples

Anime/
├── One Piece [anidbid-69]/
│   └── Season 01/
│       ├── One Piece - s01e0001.mkv
│       └── One Piece - s01e1064.mkv
├── Attack on Titan [anidbid-9541]/
│   ├── Season 01/
│   ├── Season 02/
│   └── Specials/
│       └── Attack on Titan - s00e01 - Ilse's Notebook.mkv
└── Demon Slayer (2019)/
    └── Season 02/
        └── Demon Slayer - s02e01.mkv

Coming from Plex? Compare with Plex + HAMA.

Naming Music for Jellyfin

Jellyfin's music handling is one of its strongest features — full MusicBrainz integration, sonic analysis for "instant mix" (similar to Plexamp), and respectable Android/iOS apps. Naming-wise, the rules mirror Plex closely with two minor differences in disc handling and Various Artists support.

Folder structure

Artist → Album → Track, just like Plex:

Music/
├── Pink Floyd/
│   ├── The Dark Side of the Moon (1973)/
│   │   ├── 01 - Speak to Me.flac
│   │   └── 02 - Breathe.flac
│   └── Wish You Were Here (1975)/
│       └── 01 - Shine On You Crazy Diamond Pts. 1-5.flac
└── Daft Punk/
    └── Random Access Memories (2013)/
        └── 01 - Give Life Back to Music.flac

Album year is recommended in the folder name. Track filenames start with a zero-padded track number followed by a dash and the title.

ID3 tags trump filenames

Jellyfin reads ID3 tags before filenames, like Plex. Required tags: Artist, Album, Title, Track Number. Strongly recommended: Album Artist (distinct from track artist on compilations), Year, Genre, Disc Number. Rename files without fixing tags and Jellyfin still trusts the wrong tags. The cleanest workflow is: fix tags with MusicBrainz Picard or Mp3tag first, then handle filenames second. RenameFlow's music mode reads MusicBrainz to suggest filenames but doesn't write tags — use it after a tagger.

Various Artists / compilations

Compilations and soundtracks use a "Various Artists" album artist tag — same pattern as Plex: ID3 Tag: Album Artist = "Various Artists" ID3 Tag: Artist = (individual track artist) Folder layout:

Music/
└── Various Artists/
    └── Pulp Fiction Soundtrack (1994)/
        ├── 01 - Misirlou - Dick Dale.flac
        └── 02 - Royale with Cheese - John Travolta.flac

Jellyfin displays compilations under "Various Artists" but each track keeps its real performer credit.

Track numbering

Two-digit zero-padded track number first, then optional dash and title: 01 - Track Title.flac Or just `01 Track Title.flac`. Both work. Avoid putting the artist in every track filename — it's redundant with the folder hierarchy.

Multi-disc albums

Multi-disc albums use "Disc XX" subfolders between album and tracks, plus the ID3 "Disc Number" tag on every file:

Music/
└── Pink Floyd/
    └── The Wall (1979)/
        ├── Disc 01/
        │   └── 01 - In the Flesh?.flac
        └── Disc 02/
            └── 01 - Hey You.flac

Jellyfin merges them into a continuous album view with disc dividers. Without the disc tag, tracks from disc 2 collide with disc 1 (two "01"s, two "02"s, and the scanner picks one).

Real-world examples

Music/
├── Pink Floyd/
│   ├── The Dark Side of the Moon (1973)/
│   │   ├── 01 - Speak to Me.flac
│   │   └── 10 - Eclipse.flac
│   └── The Wall (1979)/
│       ├── Disc 01/
│       │   └── 01 - In the Flesh?.flac
│       └── Disc 02/
│           └── 01 - Hey You.flac
└── Various Artists/
    └── Pulp Fiction Soundtrack (1994)/
        ├── 01 - Misirlou - Dick Dale.flac
        └── 02 - Royale with Cheese.flac

Official: Jellyfin music docs

Migrating from Plex to Jellyfin

If you're moving from Plex (subscription fatigue, telemetry concerns, simply wanting more control), here's the good news: about 80% of your Plex-compatible naming works in Jellyfin without changes. The remaining 20% — editions, anime, and a few edge cases — needs targeted renames. This section is the complete checklist.

What carries over, what doesn't

What carries over unchanged from Plex to Jellyfin: - Movie folder naming: "Title (Year)/Title (Year).mkv" works identically. - TV show folder naming: "Show (Year)/Season XX/Show - sXXeYY.mkv" works identically. - Multi-version resolution suffix: "Title (Year) - 1080p.mkv" works in both. - Music: Artist/Album/Track structure transfers without changes. - Specials and "Season 00" handling: same logic. - Date-based daily shows (YYYY-MM-DD): same format. What you have to rename: - Movie editions: Plex uses `{edition-X}` (curly braces), Jellyfin uses `[edition-X]` (square brackets). Find and replace across your movie library. - Anime libraries built around Plex's HAMA scanner: drop the HAMA-specific tags and re-enable AniDB as a metadata provider in the new Jellyfin library. Folder IDs `[anidbid-X]` carry over and work directly. - Provider IDs in folder names: Plex's `[tmdb-X]` shorthand becomes `[tmdbid-X]` in Jellyfin (note the `id` suffix). Same for tvdbid, imdbid, anidbid.

Watched status migration

Watched status doesn't migrate automatically — Plex stores it in its own database, not in the files. Three options: Option 1 — Plex Watched History Importer (community Jellyfin plugin). Reads Plex's database export and imports per-user watched marks. Works but requires Plex still running long enough to export. Option 2 — Trakt.tv sync. If you've been scrobbling to Trakt from Plex (via the Trakt plugin), enable Trakt sync in Jellyfin too. Your watched history transfers via Trakt as the bridge. Option 3 — Accept the loss and start fresh. For libraries under a few hundred items, this is often the lowest-effort path. For multi-user families, Trakt sync is the most reliable.

Plex Pass features with no direct equivalent

Some Plex Pass features have no direct Jellyfin equivalent. Know before you migrate: - DVR / Live TV: Jellyfin has Live TV via tuners (HDHomeRun, USB sticks) but the DVR scheduling UI is more bare-bones than Plex's. - Plexamp's sonic analysis: Jellyfin has basic mood/genre detection but no sonic-fingerprint similarity. Symfonium or Manet on mobile are good Plexamp-like clients. - Plex Pass-only intro skip: Jellyfin has community plugins for this (Jellyscrub, Intro Skipper) — install separately. - Plex Mobile Sync: Jellyfin's mobile apps support sync but it's less polished than Plex's. - Plex Tone Mapping / Hardware-accelerated transcoding: Jellyfin supports all major hardware acceleration but requires manual setup per platform. These are not naming concerns but they affect the "should I migrate" decision. None of them block a clean migration of the library itself.

When to migrate (and when to stay)

You're a good migration candidate if: - The Plex Pass price increase changed your math (Lifetime $250 vs Jellyfin free forever). - You want your watch history private, no telemetry. - You're on Linux/BSD/unRAID and prefer apt/Docker over Plex's official packages. - You don't need Live TV DVR scheduling. - You're OK spending an afternoon on hardware acceleration setup. You should stay on Plex if: - Family members rely on Plex's mobile sync. - You depend on Plex's polished discovery (Universal Watchlist, recommendations). - DVR is your primary use case. - You prefer paying once for a polished product over self-hosting. The naming migration itself is a 30-minute job for most libraries — the editorial conversion (`{edition}` → `[edition]`) is a one-time find-and-replace. Use RenameFlow's batch mode to automate it.

Before / after

Before (Plex):
Movies/Blade Runner (1982)/Blade Runner (1982) - {edition-Final Cut}.mkv
TV/The Office (2005)/Season 03/The Office - s03e12 - Back from Vacation.mkv
Anime [HAMA]/One Piece [anidb-69]/Season 01/One Piece - s01e1064.mkv

After (Jellyfin):
Movies/Blade Runner (1982)/Blade Runner (1982) [edition-Final Cut].mkv
TV/The Office (2005)/Season 03/The Office - s03e12 - Back from Vacation.mkv
Anime/One Piece [anidbid-69]/Season 01/One Piece - s01e1064.mkv

Three changes: curly to square brackets on the movie edition, drop the HAMA prefix folder, and rename `[anidb-X]` to `[anidbid-X]`.

Also useful: FileBot users coming from Plex.

Jellyfin Naming Troubleshooting

Six failures cover roughly 85% of Jellyfin naming complaints. Each one has a predictable cause and a clear fix.

The 60-Second Alternative

Everything above is the manual way: understand the patterns, type the filenames, fix the edge cases. Worth it once for a fresh library. Painful for a Plex migration with 2,000 files to convert.

The manual way

By hand, a Plex-to-Jellyfin naming conversion takes about 30 seconds per item if you're disciplined — find-replace the edition syntax, double-check anime folder IDs, fix any compact-form episode tokens. A 2,000-file library is 16+ hours of careful typing.

The 60-second way

RenameFlow does the conversion in seconds. Drop the Plex-named folder, the parser detects the existing pattern, suggests the Jellyfin-compliant equivalent, and renames locally on confirmation. No upload — files stay on your disk via the File System Access API. Free up to 15 files per day; €49 lifetime for the full library in one pass. For a fresh Jellyfin library starting from raw scene releases (no Plex naming to convert), RenameFlow queries TheMovieDB, TheTVDB, AniDB, and MusicBrainz in parallel and produces the Jellyfin-compliant pattern directly — matching the exact rules in this guide.

See RenameFlow plans.

Jellyfin Naming — Frequently Asked Questions

→ See all RenameFlow FAQs

Continue Reading

• → Plex naming guide (the equivalents)
• → Step-by-step renaming walkthrough
• → RenameFlow vs FileBot, TinyMediaManager, and more
• → All RenameFlow FAQs

Official references: Jellyfin movies naming (official) · Jellyfin shows naming (official) · Jellyfin music naming (official) · Jellyfin on GitHub