Do you want me to make it sequential by sorted name (so it applies in alphabetical order), or just in raw shell glob order?

G: Got it. You’ll want to force numeric sort so that 01, 02, 10 sort properly. Here’s the adjusted command:

Key Changes

⚠️ Caveat: using for f in $(ls ...) can break on filenames with spaces. If your files have spaces, safer version is:

Want me to also add a dry run version (so you can check the new names before actually renaming)?

G: Here’s a dry-run version that just shows what would be renamed without touching the files:

What it does

Once you’re satisfied, just remove the echo and run the real renaming command:

Do you want me to also add a backup/undo plan in case you run it and decide you don’t like the results?

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: Here you go — a compact Jellyfin naming & folder cheat sheet you can drop into a .txt file.

JELLYFIN QUICK SYNTAX CHEAT SHEET
=================================

GENERAL
- Use one top-level folder per library (Movies, TV, Music, etc.).
- Prefer ASCII characters; avoid weird punctuation in names.
- Year in parentheses: (1999)
- Zero-pad season/episode numbers: S01E02
- Specials go in Season 00.
- NFO and images sit alongside media with matching basenames.

----------------------------------
MOVIES
----------------------------------
Folder:
  Movies/
    Movie Name (Year)/
      Movie Name (Year).mkv

Multi-versions (editions / cuts):
  Movie Name (Year)/
    Movie Name (Year) - Director's Cut.mkv
    Movie Name (Year) - IMAX.mkv
    Movie Name (Year) - 4K.mkv   # resolution auto-detected, tag optional

Multi-part (stacked):
  Movie Name (Year) - Part 1.mkv
  Movie Name (Year) - Part 2.mkv
  # also works: - cd1 / - cd2 / - disk1 / - disk2

Extras (bonus features & trailers):
  Movie Name (Year)/
    extras/
      Behind the Scenes.mkv
      Deleted Scenes.mkv
      Featurette - Costumes.mkv
    trailers/
      Movie Name (Year) - Trailer.mkv
  # Suffix also works: Movie Name (Year)-trailer.mkv

NFO (metadata):
  Movie Name (Year)/
    movie.nfo
  # or: Movie Name (Year).nfo

Images:
  Movie Name (Year)/
    poster.jpg          # primary poster
    backdrop.jpg        # background/fanart
    folder.jpg          # also accepted as poster

----------------------------------
TV SERIES
----------------------------------
Folder layout:
  TV Shows/
    Series Name/
      Season 01/
        Series Name - S01E01 - Episode Title.mkv
      Season 02/
        Series Name - S02E01 - Episode Title.mkv

Shorthand (no title is fine):
  Series Name/Season 01/ S01E01.mkv

Multi-episode files:
  Series Name/Season 01/ Series Name - S01E01E02.mkv
  # or: S01E01-02

Specials:
  Series Name/Season 00/ Series Name - S00E01 - Special Title.mkv

Date-based episodes (daily shows):
  Series Name/Season 2019/ Series Name - 2019-05-20 - Title.mkv
  # YYYY-MM-DD format

Anime / absolute numbering (maps to Season 1):
  Series Name/
    Season 01/
      Series Name - 001.mkv
      Series Name - 002.mkv
  # Using S01E001 etc. also works

NFO:
  Series Name/
    tvshow.nfo
  Series Name/Season 01/
    S01E01.nfo                # or match the episode basename: Series Name - S01E01 - Title.nfo

Images:
  Series Name/
    poster.jpg
    backdrop.jpg
  Series Name/
    season01-poster.jpg
    season00-poster.jpg       # specials
  Series Name/Season 01/
    Series Name - S01E01 - Episode Title.jpg   # per-episode still (optional)

----------------------------------
SUBTITLES (External)
----------------------------------
Same basename + language code:
  Movie Name (Year).eng.srt
  Movie Name (Year).en.forced.srt
  Movie Name (Year).en.sdh.srt

For TV:
  Series Name - S01E01 - Title.eng.srt
  S01E01.eng.srt

Notes:
- Use ISO codes (en, eng, es, spa, fr, fra, etc.).
- “forced” or “sdh” may be appended before extension.

----------------------------------
AUDIODESCRIPTIONS (External, optional)
----------------------------------
  Movie Name (Year).descriptive.mp3
  # Or treat as an alternate version; embedded tracks are preferred.

----------------------------------
3D / VIDEO TAGS (Optional)
----------------------------------
  Movie Name (Year) - 3D HSBS.mkv
  Movie Name (Year) - 3D HOU.mkv
- Jellyfin usually detects formats/flags; tags are for human clarity.

----------------------------------
MUSIC
----------------------------------
Artists & Albums:
  Music/
    Artist Name/
      (Year) Album Title/
        01 - Track Title.flac
        02 - Track Title.flac

Multi-disc:
  Music/Artist/(Year) Album Title/CD1/ 01 - Track.flac
  Music/Artist/(Year) Album Title/CD2/ 01 - Track.flac

Cover Art:
  folder.jpg        # album cover inside the album folder
  artist.jpg        # in artist folder

----------------------------------
COLLECTIONS (Box Sets)
----------------------------------
- Prefer creating Collections inside Jellyfin.
- If you must mirror as folders: keep normal movie folders and use Collections in the UI.

----------------------------------
COMMON GOTCHAS
----------------------------------
- Don’t mix multiple movies in one folder (one movie per folder is safest).
- Zero-pad everything: Season 01, S01E03, 001.
- Avoid renaming to include release-group junk (Jellyfin ignores it, but it clutters).
- Keep NFO/Images next to their target media with matching basenames.

----------------------------------
POWER TIPS
----------------------------------
- Bulk rename (bash, numeric sort safe):
  n=1; ls -1v | while IFS= read -r f; do mv -- "$f" "s01e$(printf "%02d" $n) $f"; n=$((n+1)); done

- Multi-episode merge naming:
  Series - S01E01E02.mkv   # single file that contains both

- Specials:
  Put all specials in Season 00 and number S00E##.

- Date-based shows:
  Prefer Series - YYYY-MM-DD.ext (with matching Season folder by year).

If you want this tailored to your exact libraries (anime-heavy, documentaries, mixed cuts, etc.), say the word and I’ll trim/add sections accordingly.

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: Put season-specific OVAs in Season 00 as specials (S00E##), following the numbering used by your metadata source (usually TMDb). Then enable “Display specials within seasons they aired in” so Jellyfin shows those OVAs inside the relevant season view. If TMDb classifies an OVA as a movie, file it in your Movies library instead. citeturn0search10turn0search6turn0search4

Practical patterns

Series Name/
  Season 00/                      # all specials/OVAs live here
    Series Name - S00E07 - OVA Title.mkv    # OVA tied to Season 2, ep ~5 (per TMDb listing)
    Series Name - S00E08 - OVA 2.mkv

Turn on: Dashboard → Libraries → [your TV library] → Display → “Display specials within seasons they aired in.” Jellyfin will place each S00E## inside the season it aired with, based on the provider’s mapping. citeturn0search6
Match provider numbering. Look up the show on TMDb (or TVDB/Maze if you use those) and use their special/OVA numbers for S00E##. That’s how Jellyfin fetches the right metadata. citeturn0search16
If an OVA is listed as a movie (common for OAD/ONA releases), put it in your Movies library as Movie Name (Year).ext, optionally link it via a Collection with the series. citeturn0search4
Multi-episode OVA in one file: Series Name - S00E07E08 - OVA Title.mkv (works like any multi-ep file). citeturn0search10

Mini add-on for your cheat sheet

ANIME OVAs / SEASON-SPECIFIC SPECIALS
- File OVAs in: Season 00/ as S00E## per TMDb numbering.
- Enable: Dashboard → Libraries → Display → “Display specials within seasons they aired in.”
- If TMDb lists an OVA as a Movie: store in Movies library; use a Collection to group with the series.
- Multi-ep OVA in one file: S00E07E08 (or S00E07-08).

If you want, I’ll fold this block into the cheat sheet I gave you so you can paste one file and be done.

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: Keep both in the same season folder but make the JP files alternate versions of the same episode (same SxxExx, add a version tag like (Japanese)), so Jellyfin shows a single episode with a Versions picker. If you want Jellyfin to totally ignore the JP copies, put them in a hidden subfolder (e.g., .jp/) and enable “ignore hidden files/folders” in that library.

Option A — Alternate versions (recommended)

Series Name/
  Season 01/
    Series Name - S01E01 - Title.mkv
    Series Name - S01E01 - Title (Japanese).mkv
    Series Name - S01E02 - Title.mkv
    Series Name - S01E02 - Title (Japanese).mkv

Same episode number, added suffix (Japanese) (or - Japanese, [JP], (Eng Dub), etc.).
Jellyfin groups them under one episode; you pick the version at playback.
Ensure your TV library has group versions enabled (it usually is).

Option B — Hide from Jellyfin, just store them nearby

Series Name/
  Season 01/
    .jp/
      Series Name - S01E01 - Title (Japanese).mkv
      Series Name - S01E02 - Title (Japanese).mkv

Name the subfolder with a leading dot (.jp), and make sure the library setting Ignore hidden files and folders is on.
Jellyfin won’t import these at all; they won’t affect views or playback.

Option C — Treat them as Extras (visible but not in episode list)

Series Name/
  Season 01/
  extras/japanese/
    S01E01 - Title (Japanese).mkv
    S01E02 - Title (Japanese).mkv

Files appear in the Extras tab for the show, not interleaved with episodes.

Option D — One file, two audio tracks (cleanest UX if possible)

Remux the English and Japanese audio (and subs) into one MKV per episode.
Set per-user Preferred audio language to English so playback defaults correctly, while JP is still selectable.

Handy bulk rename (tag JP files with `(Japanese)` before extension)

From the season folder containing only the JP copies (or after selecting them via a pattern):

Pick A if you want a clean single-episode view with a version selector; pick B if you want them truly inert; pick C if you want them accessible but out of the episode list; pick D if you’re willing to remux for the tidiest long-term setup.

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: Jellyfin often leaves “phantom” items after moves. Try, in order: per-library Scan → Replace all metadata, run a couple Scheduled Tasks, use the empty-old-path trick to force a purge, and if it still won’t clear, do a targeted SQLite cleanup. citeturn2search13turn1search1turn0search2turn0search6

1) Quick UI fixes (no rebuild)

Per-library scan (not “Scan all”) → from the library’s ⋮ menu choose Scan and select Replace all metadata. This can nudge Jellyfin to drop stale pointers created by path changes. citeturn2search13
Scheduled Tasks → run Optimize database and Clean up collections and playlists from Dashboard → Scheduled Tasks. They don’t delete missing files, but they clear list junk and tighten the DB. citeturn1search1

2) “Empty-old-path” trick (UI, still safe)

If you remember the old folder path(s) you moved from:

Recreate that exact path as an empty folder, add it back as a temporary library (or as an extra folder in the same library).
Let Jellyfin scan it (it now sees those items as empty/missing).
Delete that temporary library/folder from Jellyfin.
This forces a purge of ghosts tied to the dead path. citeturn0search2

3) Why this happens

After moves, Jellyfin detects the new files but often doesn’t remove the old entries automatically, leaving duplicates (one valid, one “missing”). It’s a long-standing behavior reported by users after intra-library moves. citeturn0search6

4) Targeted SQLite cleanup (precise, fast)

If you’re comfortable touching the DB, this is the cleanest fix. Replace /old/path with the defunct root you moved away from.

Back up and stop:

5) Preventative tips

If you want, I’ll tailor the SQLite one-liner for your exact old path(s) and Jellyfin install location.

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: Here are safe, filename-only renamers for Fedora (Bash). They won’t touch file contents.

Current directory only (space-safe)

shopt -s nullglob
for f in *s01e*; do
  [[ -f "$f" ]] || continue
  mv -n -- "$f" "${f//s01e/s02e}"
done

Dry run (prints what would happen)

shopt -s nullglob
for f in *s01e*; do
  [[ -f "$f" ]] || continue
  printf 'mv -- %q %q\n' "$f" "${f//s01e/s02e}"
done

Recursive (all subfolders, filename part only)

find . -type f -name '*s01e*' -print0 |
while IFS= read -r -d '' f; do
  dir=${f%/*}
  base=${f##*/}
  new=${base//s01e/s02e}
  [[ $base == "$new" ]] && continue
  mv -n -- "$f" "$dir/$new"
done

Notes:

-n prevents overwriting if a target name already exists; switch to -i for prompts if preferred.
These match only lowercase s01e; for other cases you can run additional passes (e.g., S01E → S02E) if needed.

M: and this is a command line set?

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: Yes—those are Bash commands you can paste into a Fedora terminal.

One-liners (current directory)

Dry run:

shopt -s nullglob; for f in *s01e*; do [[ -f "$f" ]] || continue; printf 'mv -- %q %q\n' "$f" "${f//s01e/s02e}"; done

Do it:

Recursive one-liner

Simpler alternative (if rename is available on Fedora)

This rename is the util-linux variant on Fedora (literal substring replace, -n for preview).

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: Here are safe Bash one-liners for Fedora.

Dry run (list what would be removed)

find . -type f -iname '*.nfo' -print

Delete (case-insensitive, recursive)

find . -type f -iname '*.nfo' -delete

Verbose alternative (shows each removal)

find . -type f -iname '*.nfo' -print -delete

Prompt before each delete (safer)

find . -type f -iname '*.nfo' -ok rm -- {} \;

Replace . with a specific root directory if needed, e.g. /media/library.

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: Turn on NFO saver for your TV library, then run a library scan with “Replace all metadata”. Jellyfin will write .nfo files next to your shows/episodes that include the provider IDs and other identification you chose. Those NFOs are your portable “export.” citeturn1view0turn2search9

Do this

Enable NFO export

Server Dashboard → Libraries → ⋮ on your TV library → Manage Library → Metadata → Metadata savers → check Nfo (and optionally Save artwork into media folders). Save.
Jellyfin writes identification (e.g., tvdbid, tmdbid, imdbid) when NFO saver is enabled. citeturn1view0

Force-write NFOs for existing items

In that same library’s ⋮ menu choose Scan and select Replace all metadata (or run the “Refresh metadata” task with replace). This is what triggers NFO creation for already-scanned media. citeturn2search9

Confirm they’re there (Fedora CLI)

find /path/to/TV -type f -iname '*.nfo' | head

What’s in the export

Jellyfin writes provider IDs and fields into NFOs (tvdbid, tmdbid, imdbid, etc.), plus episode/season info and special-placement tags. These are exactly what fixes misidentifications and can be re-imported later. citeturn1view0

Tips that help with mis-IDs (optional)

You can also anchor identification in names (e.g., Series Name [tvdbid-123456])—useful before the export step or if you ever rebuild. citeturn0search5

Alternative/backup

Back up Jellyfin’s database (contains all metadata and IDs) via the official Backup & Restore guide. This is all-or-nothing and less portable than NFOs, but good insurance. citeturn0search2

If NFOs don’t appear

Make sure Jellyfin has write permission to the media folders, and that you ran a scan with Replace all metadata after enabling NFO saver. Some users report needing a “replace” pass for existing items before NFOs are written. citeturn2search9

That will give you a clean, file-based export of the exact IDs and metadata you used to correct Jellyfin’s matches.

[Attachment reference unresolved: file-does]

[Attachment reference unresolved: file-info]

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: There isn’t a built-in “Open on IMDb” button in the default Jellyfin web UI. Fastest paths are: (1) open Edit metadata for the item, copy the IMDb ID and paste it after https://www.imdb.com/title/, or (2) grab the IMDb ID via the Jellyfin API with a one-liner. Jellyfin uses TMDb/TVDb (not IMDb) for metadata, but it stores IMDb IDs and can read them from NFOs. citeturn4search12turn2search22turn2search12

Quick ways

A) From the UI (no plugins)

Open the movie/show → ⋯ More → Edit metadata → copy the IMDb ID shown in Provider IDs.
Open https://www.imdb.com/title/<that-id>/ in your browser.
Jellyfin’s docs and forum notes confirm IMDb isn’t a metadata source; IDs are mapped/kept for reference and in NFOs, which is why this works reliably. citeturn4search12turn2search22

B) One-liner (CLI via API)

When you’re on an item’s detail page, copy the id= GUID from the URL, then run:

This prints the exact IMDb URL if the item has one. (Jellyfin exposes external IDs under ProviderIds.) citeturn5search12turn5search19

C) If you only have a TMDb ID

Open the TMDb page (from the ID you see in Edit metadata) and follow the IMDb link shown there; Jellyfin relies on TMDb/TVDb mapping rather than IMDb’s API. citeturn4search16turn4search12

D) Optional quality-of-life

Enable NFO saver for the library and refresh metadata; your items will have .nfo files with the same IMDb/TMDb IDs next to the media, so you can grab them from disk later. citeturn2search22

Note: A long-standing feature request asks for a direct IMDb link in the UI; it isn’t standard as of recent builds. citeturn2search3

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: Jellyfin only writes .nfo files next to your media when the library’s Metadata savers → Nfo option is enabled, and you run a Refresh/Scan with “Replace all metadata.” Artwork location is a separate toggle. Check for NFOs with find, verify the server’s internal metadata path, then enable NFO saver and rescan if needed. citeturn0search0turn0search4

How to check where NFOs are going

1) Look for NFOs in your media tree (Fedora CLI)

# change this to your TV root
MEDIA=/path/to/TV
find "$MEDIA" -type f -iname '*.nfo' | head -n 20

If you see files, Jellyfin is writing NFOs into your media folders as intended. If you see nothing, proceed below. Jellyfin’s intended behavior (when enabled) is to write NFOs beside the media. citeturn0search4

2) Check Jellyfin’s internal metadata directory (for artwork/cache)

Open Dashboard → Paths and note the Metadata path (Linux default is /var/lib/jellyfin/metadata). This location is for server-side metadata/artwork, not NFOs—unless you tell Jellyfin to save artwork to media folders, images will accumulate here. citeturn0search10

CLI peek:

If NFOs aren’t appearing next to media

A) Enable the NFO saver (per library)

Dashboard → Libraries → (⋮) Manage Library → Metadata → Metadata savers → check “Nfo” → Save. This is the switch that allows writing .nfo files. citeturn0search0

B) Force Jellyfin to actually write them

C) (Optional) Put artwork in media folders too

If you also want posters/backdrops alongside the files: Manage Library → Metadata → “Save artwork into media folders.” Otherwise, artwork lives under the internal Metadata path. citeturn0search6

Common snags & fixes

That’s it. Run the find check, flip the NFO saver on, then do a Replace all metadata pass, and the .nfo files will appear alongside your shows/episodes in their relative folders. citeturn0search0turn0search4

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: find already traverses hidden folders; this will catch all .nfo files (including hidden ones) under the current directory.

If this returns nothing in your media tree, Jellyfin likely isn’t set to write NFOs to media folders or lacks write permission; enable Metadata savers → Nfo and run a Replace all metadata scan, then rerun the find command.

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: Your media folders only have artwork because NFO saver isn’t enabled (or it hasn’t been forced to write yet). Turn on Metadata savers → Nfo for the TV library, then run a Scan → Replace all metadata on that library to generate .nfo files next to your episodes. If episodes are still wrong, fix the Display Order (Aired/DVD/Absolute) on that series and/or anchor the series with a provider ID like [tvdbid-12345]. citeturn0search0turn0search10turn3view0

Make Jellyfin write NFOs into your media folders

Server Dashboard → Libraries → ⋮ on your TV library → Manage Library → Metadata
- Check Metadata savers → Nfo.
- (Optional) Check Save artwork into media folders if you also want posters/backdrops alongside files. citeturn0search0turn0search6
Force-write NFOs for existing items
- Library ⋮ → Scan → Replace all metadata (or run a “Refresh metadata” with replace). By design, enabling NFO saver doesn’t retro-write until you do this replace pass. citeturn0search10
Verify on disk (Fedora CLI)

find /path/to/TV -type f -iname '*.nfo' -print | head -n 20

If nothing appears, it’s almost always because NFO saver wasn’t enabled or Jellyfin can’t write to the media path (fix permissions for the jellyfin user).

Why the episodes look wrong (and how to fix fast)

Mislabeling usually comes from ordering mismatches (Aired vs DVD vs Absolute) or from provider differences (TMDb vs TVDB). Fix at the series level:

Open the series → ⋮ Edit metadata → set Display order to Aired / DVD / Absolute as appropriate, then refresh that series/season. This setting determines how episodes map to your SxxExx filenames. citeturn0search2turn0search17
If specials are interleaving weirdly, toggle Dashboard → Library → Display → “Display specials within their series they aired in.” This remaps S00 items into seasons when the provider has air placement data. citeturn3view0
Anchor the series to the correct metadata record by adding an external ID to the series folder name, e.g.:
Series Name (2015) [tvdbid-123456] or [tmdbid-98765]. Jellyfin honors these tags and will match accordingly. citeturn3view0

Quick ways to see what Jellyfin thinks (IDs & numbering)

If you don’t have NFOs yet, pull it via API so you can spot the bad mapping:

Grab the series’ GUID (copy id= from its URL in the web UI).
Run (replace SERVER, APIKEY, SERIESGUID):

curl -s "http://SERVER:8096/Items?ParentId=SERIESGUID&Recursive=true&IncludeItemTypes=Episode&Fields=ProviderIds,Path,IndexNumber,ParentIndexNumber" \
  -H "X-MediaBrowser-Token: APIKEY" \
| jq -r '.Items[] | [(.ParentIndexNumber|tostring), (.IndexNumber|tostring), .Name, .ProviderIds.Tvdb, .ProviderIds.Tmdb, .Path] | @tsv'

This lists Season, Episode, Title, TVDB/TMDB IDs, and Path for each episode so you can spot where numbering diverges. (The API returns ProviderIds and index numbers; auth typically uses X-MediaBrowser-Token.) citeturn2search7

If one season is consistently off

Rename files to the provider’s numbering (or use multi-ep names like S01E01E02 if one file contains two). Supported patterns and special handling are documented in the TV naming guide. citeturn3view0
After correcting, Refresh metadata on the series/season and Lock metadata once it’s correct to prevent drift.

Sanity checklist

NFO saver is on and you ran Replace all metadata (otherwise no .nfo will ever appear). citeturn0search0turn0search10
Display Order matches how you named files (Aired/DVD/Absolute). citeturn0search2
Specials behavior is intentional for your library. citeturn3view0
Optionally pin the series by adding [tvdbid-…] or [tmdbid-…] to the series folder. citeturn3view0

If you want, tell me the series title and whether you want Aired/DVD/Absolute, and I’ll give you the exact rename/refresh sequence that will line it up cleanly.

[Attachment reference unresolved: file-paths]

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: Short answer: there isn’t a reliable switch to make the AniSearch plugin show 18+ (NSFW) titles in Jellyfin right now. The official AniSearch plugin for Jellyfin currently scrapes the AniSearch website (not a logged-in API), and mature pages on AniSearch are typically behind an age gate. Because the plugin doesn’t offer a login/age-confirmation flow, those entries often don’t come back in Jellyfin searches. You can see from the plugin repo that it’s a simple site scraper, and there’s even an open request asking maintainers to move to AniSearch’s API “to avoid getting banned,” which hints at the brittleness of scraping here. citeturn8view0turn17search2

What you can do instead (and what actually works)

Use Shoko + Shokofin (recommended for anime libraries, including adult/hentai).
Shoko ingests metadata directly from AniDB (which includes adult titles) and feeds it to Jellyfin via the Shokofin plugin. Shoko’s docs explicitly say adult content is supported as long as AniDB has an entry. After installing Shokofin, connect it to your Shoko Server and let it provide metadata for that library. (Important: when using Shokofin, don’t enable NFO saving in that library; Shoko warns it will break overrides.) citeturn16search5turn16search0turn19search8
Prioritize other anime providers over AniSearch.
In your Anime library’s Metadata fetchers order, put AniDB and/or AniList above AniSearch so they’re tried first. The Jellyfin docs list these plugins and the forum guidance often recommends using multiple providers with a sensible priority. citeturn12search4turn18search10
For anime movies or shows that exist on TMDb:
Make sure your TMDb provider is allowed to return adult results (there’s an “Include adult content” toggle in TMDb provider settings per library). This won’t fix AniSearch, but it will help when TMDb actually has the title. citeturn12search13
Lock problem items by ID (where possible).
Jellyfin can lock matches by putting an external ID in the folder name, e.g.
Series Name (2018) [tmdbid-123456] or Series Name (2018) [tvdbid-654321].
This is helpful when the title exists on TMDb/TVDB. (Jellyfin’s naming docs show the external-ID pattern.) citeturn19search0

Bottom line

AniSearch + NSFW: there’s no user-toggle today; the plugin’s scraping approach doesn’t handle age-gated pages. (There’s an open issue to move to the API, but it’s not implemented.) citeturn17search2
If you need consistent NSFW anime metadata in Jellyfin, Shoko + Shokofin is the path that actually works. citeturn16search5turn16search0

If you want, I can jot down quick step-by-step for installing Shokofin and flipping your Anime library over to it.

[Attachment reference unresolved: file-title]

[Attachment reference unresolved: file-names]

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: Jellyfin’s filename/folder ID tags work with IMDb, TMDb, and TVDb. Use these exact prefixes (brackets required):

[imdbid-tt12345678]
[tmdbid-12345]
[tvdbid-67890] (TV shows only)
You can put more than one in the same name. AniDB (and AniList) do not have an official, supported “[anidbid-12345]”–style tag today. Use the Identify dialog, NFOs, or Shoko/Shokofin instead. citeturn2search10turn0search3

Supported external-ID tags

Movies / Series folders/files accept: [imdbid-tt########], [tmdbid-#####], [tvdbid-#####]. Multiple IDs may be included, e.g. Show (2015) [imdbid-tt01234567] [tmdbid-12345]. citeturn0search0turn0search3
TVDb applies to shows (not movies). citeturn0search3

About AniDB / AniList

There’s no documented Jellyfin core support for [anidbid-#####] in names; an open plugin issue asks for this and related docs, but it isn’t implemented. citeturn3search14
Users report that putting AniDB/Anilist IDs in directory names doesn’t drive identification; you must use Identify or another provider. citeturn2search15
Practical workarounds that do work:
- Use Identify on the series and enter the AniDB/TMDb/TVDb ID directly. citeturn3search16
- Save NFOs with provider IDs and refresh (Jellyfin reads those). citeturn2search10
- For anime-heavy libraries (including NSFW), Shoko + Shokofin supplies AniDB metadata robustly. citeturn2search14

Copy-paste examples

Movies/
  Perfect Blue (1997) [tmdbid-10494] [imdbid-tt0156887]/ 
    Perfect Blue (1997) [tmdbid-10494] [imdbid-tt0156887].mkv

TV Shows/
  Mononoke (2007) [tvdbid-80379] [tmdbid-12589]/
    Season 01/
      Mononoke - S01E01.mkv

These patterns are exactly what Jellyfin’s docs describe and will anchor matching reliably. citeturn0search3turn2search10

[Attachment reference unresolved: file-names]

[Attachment reference unresolved: file-naming]

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: Short answer (as of Aug 30, 2025): none of AniDB, AniList, AniSearch, or Kitsu offer a native “download NFO” feature. They expose data via APIs or web pages, but NFO is a Kodi/Emby/Jellyfin format you generate yourself (or with a tool). citeturn5search4turn5search0turn6search4

What each source actually provides

AniDB → has HTTP/UDP APIs (XML/UDP), no NFO export. Third-party tools can pull AniDB and write NFOs. citeturn7search0turn7search1
AniList → GraphQL API (JSON), no NFO export. You can export lists via community tools, but that’s not NFO. citeturn5search4turn5search21
AniSearch → Jellyfin plugin scrapes the site; there’s no official API or NFO export from AniSearch. citeturn6search4
Kitsu → JSON:API, no NFO export. (Docs show API endpoints; not NFO files.) citeturn5search3

Practical ways to get NFOs anyway (these work)

tinyMediaManager (tMM) – scrape with AniDB (tMM supports it) and write NFOs for Jellyfin/Kodi.
- tMM advertises NFO import/export and an AniDB scraper. citeturn0search20turn8search1turn8search14
Akiba (CLI) – pulls AniDB and writes stub tvshow/episode NFOs tailored for Jellyfin. Great for absolute numbering. citeturn4view0
Roll your own – Jellyfin will read valid local NFOs you place next to media (good for manual fixes). citeturn0search4
(There are other niche generators—e.g., Dantalian uses Bangumi to create NFOs if that DB serves your titles.) citeturn6search16

Minimal “pin it by ID” NFO templates (copy/paste)

Place these next to your media; they help Jellyfin lock identification.

tvshow.nfo

If you want, I can give you a 2–3 step tMM or Akiba workflow tailored to your library (which source to prioritize, where to drop the NFOs, and how to refresh Jellyfin).

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: For most people, tinyMediaManager (tMM) is simpler: install → pick scrapers → hit Scrape → it writes Jellyfin-compatible NFOs (GUI or CLI). Akiba is great if you specifically want a CLI that pulls from AniDB and outputs stub NFOs that fix absolute numbering—but it needs more setup (AniDB client IDs/tokens, first-run config, build/install). citeturn5view0turn4view0turn1view0

What “simple” looks like in practice

tinyMediaManager — easiest end-to-end

Built-in NFO writing for Jellyfin; just enable the scrapers you want and run a scrape/rename. Works via GUI and headless CLI. citeturn5view0turn4view0
Has official scrapers for TMDb, IMDb, TVDB, AniDB (and more), so you don’t have to bolt on extra tools. citeturn2view0
Sample headless run (TV shows):
```
tinyMediaManager tvshow -u -n -w
# -u scan, -n scrape new, -w rewrite NFOs
```
(CLI flags shown in the docs.) citeturn4view0
If you need adult titles via TMDb, there’s a “Include adult movies” checkbox in the TMDb scraper. citeturn2view0

Verdict: Minimum moving parts, friendliest UX, and you can still automate later with the CLI. citeturn5view0turn4view0

Akiba — simplest if you want pure CLI + AniDB stubs

Purpose-built for anime: renames and writes tvshow/episode NFOs from AniDB, designed to fix absolute numbering for Jellyfin. citeturn1view0
Requires a little upfront config:
- Build/install (bun install, copy binary).
- Set AniDB HTTP client for write-nfo; optional poster saving/overwrite.
- For renaming, set AniDB UDP client and your AniDB creds; optional TMDb/Anilist tokens for cross-mapping. citeturn1view0
Minimal flow to write NFOs:
```
# one-time
akiba configure --anidb-http-client examplehttpclient/1
# per library
akiba write-nfo
```
(Further options and id-mapping commands in the README.) citeturn1view0

Verdict: Lean and fast once configured, but setup is more technical than tMM (registering AniDB clients, tokens, first-run config, building the binary). citeturn1view0

Recommendation

If you want the least fuss and a visual sanity check while you fix IDs and write NFOs, go with tinyMediaManager. It’s explicitly documented to produce NFOs that Jellyfin reads, and it has both GUI and scripting modes. citeturn5view0turn4view0
If your library is anime-heavy and you prefer terminal-only with AniDB-accurate stubs, Akiba is a good fit—just expect a few setup steps. citeturn1view0

Third option (for anime-heavy/NSFW libraries)

If you’d rather skip NFOs entirely and let a backend handle anime metadata (including adult titles) for Jellyfin, run Shoko Server + the Shokofin plugin. It feeds Jellyfin directly from AniDB and is documented to handle adult entries when AniDB has them. Simpler day-to-day after one-time setup. citeturn3search0turn3search1turn3search4

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: Here’s the official, simplest way to install tinyMediaManager (tMM) on Fedora, straight from the docs.

Method 1 — Portable Linux tarball (recommended)

tMM v4+ ships with its own Java runtime, so you don’t need to install Java. citeturn2view0

Download the Linux package
Go to the download page and grab the Linux (amd64) Universal Package (.tar.xz). citeturn3search1
Extract & run

# pick where you want it to live
mkdir -p "$HOME/apps" && cd "$HOME/apps"
# adjust the filename to the one you downloaded
tar -xJf ~/Downloads/tinyMediaManager-*-linux-amd64.tar.xz
cd tinyMediaManager
# launch
./tinyMediaManager

Linux install is literally “extract the archive and run the binary.” citeturn2view0

(Optional) Create a desktop launcher
Run this from inside the extracted tinyMediaManager folder so the Icon/Exec paths resolve correctly:

cat <<'EOM' >~/.local/share/applications/tinyMediaManager.desktop
[Desktop Entry]
Type=Application
Terminal=false
Name=tinyMediaManager
Icon=%k/tmm.png
Exec=%k/tinyMediaManager
EOM

On the official page they provide a similar snippet; it lets tMM show up in your app menu. citeturn2view0

(If you’re missing MediaInfo)
If tMM complains about MediaInfo, install it (used to read file technical data):

sudo dnf install mediainfo libmediainfo

Or grab the official builds from MediaArea if your repo version causes issues. citeturn2view0

Method 2 — Docker/Podman (optional)

There’s an official Docker image. It’s marked “experimental” and running GUI apps in containers on Fedora/Wayland needs extra setup, so most users stick to the tarball. If you want it anyway, see the image page for details. citeturn3search2

Headless / CLI usage (after installing)

tMM has a built-in command-line interface you can run from the extracted folder, useful for automations (scan/scrape/write NFOs, etc.). Docs and examples live here: citeturn0search3

If you want, tell me where you put it (e.g., /home/you/apps/tinyMediaManager) and what you want to automate, and I’ll hand you ready-to-paste CLI lines.

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: You’re right—sorry I didn’t flag the licensing earlier.

tinyMediaManager (tMM): There’s a FREE edition and a PRO edition. The free edition already supports importing/exporting NFOs, renaming, CLI, etc. PRO is a paid subscription (~12 € / year) that unlocks extra features; you don’t need PRO just to write Jellyfin-compatible NFOs. citeturn2view0turn0search0
Akiba: Free & open-source (MIT-licensed). It’s a CLI specifically for anime that can rename and export stub NFOs from AniDB mappings. No cost, you just install/build it from the repo or use its releases. citeturn1view0

If you want a zero-cost path today: use tMM Free for GUI-driven NFOs or Akiba for AniDB-accurate stub NFOs, and Jellyfin will read either.

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: docker pull shokoanime/server:latest downloaded the Shoko Server image to your Fedora box. Next steps: run the container (map port 8111, mount a config folder and your anime folder), open the Web UI, finish setup, then install the Shokofin plugin in Jellyfin and point it at Shoko. citeturn0search6turn0search2

1) Run Shoko Server (Docker)

Pick where to store Shoko’s config, then launch:

Docs confirm the port and a standard docker run similar to the above. citeturn0search2turn0search8

2) Initial Shoko setup (Web UI)

3) Connect Jellyfin via Shokofin

4) Point your Jellyfin Anime library at Shoko

5) Optional niceties

That’s the whole path from pulling the image to seeing anime in Jellyfin via Shokofin, with 8111 exposed and persistent config under ~/.shoko.

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: Short version: No—you don’t have to mount your media/import folders on the very first run. For a clean start, just map a persistent config folder and the port; you can add the library mounts later by recreating the container with the same config volume.

Minimal first run (keeps your setup/data)

mkdir -p "$HOME/.shoko"
docker run -d --name shokoserver --restart unless-stopped \
  -p 8111:8111 \
  -v "$HOME/.shoko:/home/shoko/.shoko:Z" \
  -e PUID=$(id -u) -e PGID=$(id -g) \
  ghcr.io/shokoanime/server:latest

This lets you open http://localhost:8111, make your admin account, poke around, etc.
The :Z is important on Fedora (SELinux) so the container can write to the mapped directory.

Add your library paths later

When you’re ready to import, recreate the container with media mounts (config is preserved):

Then in Shoko’s Web UI: Settings → Import → add /mnt/anime (and /mnt/import if used) and run a scan.

Notes

This gives you a safe, low-friction first boot and a clean path to wire in your library afterward.

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: In Shoko, an import folder is just a path Shoko scans/uses. For a safe trial, add one import folder that points to your mounted library (e.g., /mnt/anime) and set Drop Type = Destination (or Both). Disable moving/renaming so nothing gets touched, then run a scan. You can add a separate Source “drop” folder later for auto-moves. citeturn0search1turn0search4

What the choices mean (pick one now)

Source: a staging/drop folder; Shoko will move files out of it to a Destination during import if moving is enabled. citeturn0search1
Destination: a real library folder; Shoko keeps files here and can rename them if you allow it. Needed as the target when you also have a Source. citeturn0search4
Both: lets Shoko treat the same folder as target and (optionally) allow in-place renaming without relocating files. Useful if you want rename-on-import later. citeturn0search1turn0search18

Safe trial setup (no file moves)

In Shoko Web UI → Settings → Import → Add Import Folder:

Folder Path: /mnt/anime (your Docker bind-mount)
Name: anime
Drop Type: Destination (or Both if you think you’ll rename in place later) citeturn0search1

Then in Settings → (General/Server) or Import options:

Turn OFF: Move on Import and Move After Rename. With only a Destination folder, nothing will move anyway; keeping these off is the safest start. citeturn0search4

Finally:

Run a Scan (Hash/Import). It will index and fetch metadata but won’t move/rename anything.
If you later want auto-sorting: add a second import folder (e.g., /mnt/import) with Drop Type = Source, then enable Move on Import so Source → Destination moves happen. citeturn0search4

Extra notes (handy later)

Renamers (Lua/WebAOM) only pick folders marked Destination or Both as valid targets. If you experiment with renaming, keep your library folder set that way. citeturn0search12turn0search6
You can safely change drop types or add/remove import folders anytime; your database stays intact.
When you connect Jellyfin via Shokofin, it will map each Jellyfin path to the corresponding import folder you defined in Shoko. citeturn0search2

That’s the safest “it works but touches nothing” configuration for a first run.

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: Yes—you can use /mnt as the import folder for this trial. Set it to Drop Type = Destination (or Both), and turn off all moving/renaming so nothing is touched. Shoko will just scan everything under /mnt recursively and build metadata.

Safe trial setup

In Shoko → Settings → Import → Add Import Folder
- Folder Path: /mnt
- Name: mnt
- Drop Type: Destination (or Both if you might rename in-place later)
In Shoko import options, disable:
- Move on Import
- Move after Rename
- Any auto-delete/cleanup options
Run a Scan/Hash. Shoko will index files under /mnt without moving or renaming anything.

Why this is safe

With Drop Type = Destination and moves disabled, Shoko will not relocate files.
Using /mnt just means “scan everything underneath.” If you later split to /mnt/anime and /mnt/import, you can change/add folders without losing the DB.

Fedora/Docker notes

Ensure the container can read /mnt: your docker run volume should include :Z for SELinux, e.g. -v "/path/on/host:/mnt:Z".
Quick visibility check:
```
docker exec -it shokoserver bash -lc 'ls -la /mnt | head'
```
If you don’t see your files there, fix the bind mount first.

Later (when you’re ready)

Change the import folder to /mnt/anime (Destination) and optionally add /mnt/import (Source), then enable Move on Import if you want automated sorting.
Renamers will only target folders marked Destination or Both, so keep your library path set that way.

M: what is the mnt directory in linux, anyway

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: TL;DR: /mnt is just a conventional, empty directory reserved for temporary mount points. It isn’t magical—admins create subfolders under it and mount filesystems there. If nothing is mounted, it’s just a normal folder.

What `/mnt` is

Part of the Linux Filesystem Hierarchy: a generic place to mount things (disks, network shares, bind mounts) temporarily.
Empty by default; you decide the subfolders (e.g., /mnt/usb, /mnt/share, /mnt/anime).
Not the same as your data directory—mounting over a path hides whatever was there until you unmount.

`/mnt` vs `/media`

/media and (on modern desktops) /run/media/$USER/<label> are where desktop auto-mounters put removable drives.
/mnt is for manual/admin mounts. Totally fine to use it as a convenient anchor, especially on servers and in containers.

Common CLI you’ll actually use

# See what is mounted anywhere (tree view)
findmnt

# See what (if anything) is mounted under /mnt
findmnt -R /mnt

# Example: mount a USB partition
sudo mkdir -p /mnt/usb
sudo mount /dev/sdb1 /mnt/usb
# ...use files...
sudo umount /mnt/usb

Persistent mount (fstab) example:

/dev/sdb1  /mnt/usb  ext4  defaults,noatime  0  2

Network share examples:

# NFS
server:/export/anime  /mnt/anime  nfs   vers=4.2,_netdev  0  0
# SMB/CIFS
//server/share       /mnt/share  cifs  credentials=/root/.smb,iocharset=utf8,_netdev  0  0

Fedora + Docker/Podman notes (relevant to your Shoko trial)

Inside a container, /mnt is just a directory in the container filesystem. You typically bind-mount a host path to it:
```
# Host → Container (SELinux-aware)
-v "/host/path/anime:/mnt/anime:Z"
```
On Fedora with SELinux enforcing, use :Z on your -v bind mounts or pre-label the host path with chcon to avoid permission denials.
If you only want a scan and zero risk of moves, it’s fine to point Shoko at /mnt (or /mnt/anime) as an Import Folder with Drop Type = Destination and moving/renaming disabled, as you’re doing.

Good practices

Create a subdirectory per mount (e.g., /mnt/anime) rather than dumping files directly in /mnt.
Don’t keep important files under a path you plan to mount over; they’ll be hidden while the mount is active.
Use findmnt or mount to verify where things really are before housekeeping or rsync work.

That’s all you need to confidently use /mnt as a safe, conventional mount point for your trial and future setups.

M: okay, so here's the current situation: my stuff is on an external drive, "/run/media/david/Expansion Hole/series-animated/". i want it to stay there. first, how do i shut down shoko. then, knowing that's the directory/target/whatever they're calling it, what should i do/how do i launch shoko correctly?

G: [Non-text content: thoughts; content_type=thoughts]

G: [Non-text content: reasoning_recap; content_type=reasoning_recap]

G: Got you. Here’s the clean, safe way to switch Shoko over to your external drive at
/run/media/david/Expansion Hole/series-animated/ and keep your data where it is.

1) Stop (and remove) any existing Shoko container

docker ps
docker stop shokoserver 2>/dev/null || true
docker rm   shokoserver 2>/dev/null || true

2) Launch Shoko with your external drive mounted read-only

Read-only is safest for a trial. SELinux on Fedora needs :Z. Quotes handle the space in “Expansion Hole”.

mkdir -p "$HOME/.shoko"

docker run -d --name shokoserver --restart unless-stopped \
  -p 8111:8111 \
  -v "$HOME/.shoko:/home/shoko/.shoko:Z" \
  -v "/run/media/david/Expansion Hole/series-animated:/mnt/anime:ro,Z" \
  -e PUID=$(id -u) -e PGID=$(id -g) \
  ghcr.io/shokoanime/server:latest

Notes

:ro,Z → mount read-only, label for SELinux.
PUID/PGID match your user so the container can read user-mounted media.

If another machine needs to reach Shoko, open the port:

sudo firewall-cmd --add-port=8111/tcp --permanent
sudo firewall-cmd --reload

3) Verify the mount from inside the container

docker exec -it shokoserver bash -lc 'ls -la /mnt/anime | head'

If you don’t see your shows, the bind path is wrong or SELinux labeling is missing.

4) Point Shoko at the folder (no moves, no renames)

In the Shoko web UI at http://localhost:8111:

Settings → Import → Add Import Folder
- Folder Path: /mnt/anime
- Name: anime
- Drop Type: Destination (or Both if you ever want rename-in-place later)
Make sure Move on Import and Move after Rename are off.
Run a Scan/Hash to build the library without touching files.

5) Later, if you decide you want writes

Recreate the container with the mount writable (drop ro,):

docker stop shokoserver && docker rm shokoserver
docker run -d --name shokoserver --restart unless-stopped \
  -p 8111:8111 \
  -v "$HOME/.shoko:/home/shoko/.shoko:Z" \
  -v "/run/media/david/Expansion Hole/series-animated:/mnt/anime:Z" \
  -e PUID=$(id -u) -e PGID=$(id -g) \
  ghcr.io/shokoanime/server:latest

Then enable renaming or add a separate Source drop folder if you want auto-moves.

That’s it. You’ve shut Shoko down, relaunched with a safe read-only bind to your external drive, and you can index everything without moving a single file.

Breakdown

Notes

Key Changes

What it does

Practical patterns

Mini add-on for your cheat sheet

Option A — Alternate versions (recommended)

Option B — Hide from Jellyfin, just store them nearby

Option C — Treat them as Extras (visible but not in episode list)

Option D — One file, two audio tracks (cleanest UX if possible)

Handy bulk rename (tag JP files with (Japanese) before extension)

1) Quick UI fixes (no rebuild)

2) “Empty-old-path” trick (UI, still safe)

3) Why this happens

4) Targeted SQLite cleanup (precise, fast)

5) Preventative tips

Current directory only (space-safe)

Dry run (prints what would happen)

Recursive (all subfolders, filename part only)

One-liners (current directory)

Recursive one-liner

Simpler alternative (if rename is available on Fedora)

Dry run (list what would be removed)

Delete (case-insensitive, recursive)

Verbose alternative (shows each removal)

Prompt before each delete (safer)

Do this

What’s in the export

Tips that help with mis-IDs (optional)

Alternative/backup

If NFOs don’t appear

Quick ways

A) From the UI (no plugins)

B) One-liner (CLI via API)

C) If you only have a TMDb ID

D) Optional quality-of-life

How to check where NFOs are going

1) Look for NFOs in your media tree (Fedora CLI)

2) Check Jellyfin’s internal metadata directory (for artwork/cache)

If NFOs aren’t appearing next to media

A) Enable the NFO saver (per library)

B) Force Jellyfin to actually write them

C) (Optional) Put artwork in media folders too

Common snags & fixes

Make Jellyfin write NFOs into your media folders

Why the episodes look wrong (and how to fix fast)

Quick ways to see what Jellyfin thinks (IDs & numbering)

If one season is consistently off

Sanity checklist

What you can do instead (and what actually works)

Bottom line

Supported external-ID tags

About AniDB / AniList

Copy-paste examples

What each source actually provides

Practical ways to get NFOs anyway (these work)

Minimal “pin it by ID” NFO templates (copy/paste)

What “simple” looks like in practice

tinyMediaManager — easiest end-to-end

Akiba — simplest if you want pure CLI + AniDB stubs

Recommendation

Third option (for anime-heavy/NSFW libraries)

Method 1 — Portable Linux tarball (recommended)

Method 2 — Docker/Podman (optional)

Headless / CLI usage (after installing)

1) Run Shoko Server (Docker)

2) Initial Shoko setup (Web UI)

3) Connect Jellyfin via Shokofin

4) Point your Jellyfin Anime library at Shoko

5) Optional niceties

Minimal first run (keeps your setup/data)

Add your library paths later

Notes

What the choices mean (pick one now)

Safe trial setup (no file moves)

Extra notes (handy later)

Safe trial setup

Why this is safe

Fedora/Docker notes

Later (when you’re ready)

Handy bulk rename (tag JP files with `(Japanese)` before extension)

Simpler alternative (if `rename` is available on Fedora)

What `/mnt` is

`/mnt` vs `/media`