track count fix

Local tracks in Jellyfin playlist are now returned first, with
matched external tracks (from squid.wtf) appended at the end.

Previously the code tried to match local tracks by exact title/artist
which often failed due to naming differences.

.env.example

@@ -6,6 +6,10 @@ BACKEND_TYPE=Subsonic
 # Enable Redis caching for metadata and images (default: true)
 REDIS_ENABLED=true
 
+# Redis data persistence directory (default: ./redis-data)
+# Redis will save snapshots and append-only logs here to persist cache across restarts
+REDIS_DATA_PATH=./redis-data
+
 # ===== SUBSONIC/NAVIDROME CONFIGURATION =====
 # Server URL (required if using Subsonic backend)
 SUBSONIC_URL=http://localhost:4533
@@ -30,6 +34,12 @@ MUSIC_SERVICE=SquidWTF
 # Path where downloaded songs will be stored on the host (only applies if STORAGE_MODE=Permanent)
 DOWNLOAD_PATH=./downloads
 
+# Path where favorited external tracks are permanently kept
+KEPT_PATH=./kept
+
+# Path for cache files (Spotify missing tracks, etc.)
+CACHE_PATH=./cache
+
 # ===== SQUIDWTF CONFIGURATION =====
 # Different quality options for SquidWTF. Only FLAC supported right now
 SQUIDWTF_QUALITY=FLAC
@@ -95,3 +105,47 @@ STORAGE_MODE=Permanent
 # Based on last access time (updated each time the file is streamed)
 # Cache location: /tmp/allstarr-cache (or $TMPDIR/allstarr-cache if TMPDIR is set)
 CACHE_DURATION_HOURS=1
+
+# ===== SPOTIFY PLAYLIST INJECTION (JELLYFIN ONLY) =====
+# REQUIRES: Jellyfin Spotify Import Plugin (https://github.com/Viperinius/jellyfin-plugin-spotify-import)
+# This feature intercepts Spotify Import plugin playlists (Release Radar, Discover Weekly) and fills them
+# with tracks auto-matched from external providers (SquidWTF, Deezer, Qobuz)
+# Uses JELLYFIN_URL and JELLYFIN_API_KEY configured above (no separate credentials needed)
+
+# Enable Spotify playlist injection (optional, default: false)
+SPOTIFY_IMPORT_ENABLED=false
+
+# Sync schedule: When does the Spotify Import plugin run?
+# Set these to match your plugin's sync schedule in Jellyfin
+# Example: If plugin runs daily at 4:15 PM, set HOUR=16 and MINUTE=15
+SPOTIFY_IMPORT_SYNC_START_HOUR=16
+SPOTIFY_IMPORT_SYNC_START_MINUTE=15
+
+# Sync window: How long to search for missing tracks files (in hours)
+# The fetcher will check every 5 minutes within this window
+# Example: If plugin runs at 4:15 PM and window is 2 hours, checks from 4:00 PM to 6:00 PM
+SPOTIFY_IMPORT_SYNC_WINDOW_HOURS=2
+
+# Playlists configuration (SIMPLE FORMAT - recommended for .env files)
+# Comma-separated lists - all three must have the same number of items
+#
+# 1. Playlist IDs (get from Jellyfin playlist URL: https://jellyfin.example.com/web/#/details?id=PLAYLIST_ID)
+SPOTIFY_IMPORT_PLAYLIST_IDS=
+#
+# 2. Playlist names (as they appear in Jellyfin)
+SPOTIFY_IMPORT_PLAYLIST_NAMES=
+#
+# 3. Local track positions (optional - defaults to "first" if not specified)
+#    - "first": Local tracks appear first, external tracks at the end
+#    - "last": External tracks appear first, local tracks at the end
+SPOTIFY_IMPORT_PLAYLIST_LOCAL_TRACKS_POSITIONS=
+#
+# Example with 4 playlists:
+# SPOTIFY_IMPORT_PLAYLIST_IDS=4383a46d8bcac3be2ef9385053ea18df,ba50e26c867ec9d57ab2f7bf24cfd6b0,8203ce3be9b0053b122190eb23bac7ea,7c2b218bd69b00e24c986363ba71852f
+# SPOTIFY_IMPORT_PLAYLIST_NAMES=Discover Weekly,Release Radar,Today's Top Hits,On Repeat
+# SPOTIFY_IMPORT_PLAYLIST_LOCAL_TRACKS_POSITIONS=first,first,last,first
+#
+# Advanced: JSON array format (use only if you can't use the simple format above)
+# Format: [["PlaylistName","JellyfinPlaylistId","first|last"],...]
+# Note: This format may not work in .env files due to Docker Compose limitations
+# SPOTIFY_IMPORT_PLAYLISTS=[["Discover Weekly","4383a46d8bcac3be2ef9385053ea18df","first"],["Release Radar","ba50e26c867ec9d57ab2f7bf24cfd6b0","last"]]

.gitignore

@@ -74,6 +74,12 @@ obj/
 downloads/
 !downloads/.gitkeep
 
+# Kept music files (favorited external tracks)
+kept/
+
+# Cache files (Spotify missing tracks, etc.)
+cache/
+
 # Docker volumes
 redis-data/
 
@@ -83,4 +89,7 @@ apis/*.json
 !apis/jellyfin-openapi-stable.json
 
 # Original source code for reference
-originals/
+originals/
+
+# Sample missing playlists for Spotify integration testing
+sampleMissingPlaylists/

README.md

@@ -16,13 +16,18 @@ Please report all bugs as soon as possible, as the Jellyfin addition is entirely
 Using Docker (recommended):
 
 ```bash
-# 1. Pull the latest image
-docker-compose pull
+# 1. Download the docker-compose.yml file and the .env.example file to a folder on the machine you have Docker
+
+curl -O https://raw.githubusercontent.com/SoPat712/allstarr/refs/heads/main/docker-compose.yml \
+     -O https://raw.githubusercontent.com/SoPat712/allstarr/refs/heads/main/.env.example
 
 # 2. Configure environment
 cp .env.example .env
 vi .env  # Edit with your settings
 
+# 3. Pull the latest image
+docker-compose pull
+
 # 3. Start services
 docker-compose up -d
 
@@ -35,7 +40,7 @@ The proxy will be available at `http://localhost:5274`.
 
 ### Nginx Proxy Setup (Required)
 
-This service only exposes ports internally. You **must** use nginx to proxy to it:
+This service only exposes ports internally. You can use nginx to proxy to it, however PLEASE take significant precautions before exposing this! Everyone decides their own level of risk, but this is currently untested, potentially dangerous software, with almost unfettered access to your Jellyfin server. My recommendation is use Tailscale or something similar!
 
 ```nginx
 server {
@@ -78,6 +83,7 @@ This project brings together all the music streaming providers into one unified
 - **Transparent Proxy**: Sits between your music clients and media server
 - **Automatic Search**: Searches streaming providers when songs aren't local
 - **On-the-Fly Downloads**: Songs download and cache for future use
+- **Favorite to Keep**: When you favorite an external track, it's automatically copied to a permanent `/kept` folder separate from the cache
 - **External Playlist Support**: Search and download playlists from Deezer, Qobuz, and SquidWTF with M3U generation
 - **Hi-Res Audio**: SquidWTF supports up to 24-bit/192kHz FLAC
 - **Full Metadata**: Downloaded files include complete ID3 tags (title, artist, album, track number, year, genre, BPM, ISRC, etc.) and cover art
@@ -85,6 +91,7 @@ This project brings together all the music streaming providers into one unified
 - **Artist Deduplication**: Merges local and streaming artists to avoid duplicates
 - **Album Enrichment**: Adds missing tracks to local albums from streaming providers
 - **Cover Art Proxy**: Serves cover art for external content
+- **Spotify Playlist Injection** (Jellyfin only): Intercepts Spotify Import plugin playlists (Release Radar, Discover Weekly) and fills them with tracks auto-matched from streaming providers
 
 ## Supported Backends
 
@@ -243,6 +250,10 @@ Choose your preferred provider via the `MUSIC_SERVICE` environment variable. Add
 |---------|-------------|
 | `SquidWTF:Quality` | Preferred audio quality: `FLAC`, `MP3_320`, `MP3_128`. If not specified, the highest available quality for your account will be used |
 
+**Load Balancing & Reliability:**
+
+SquidWTF uses a round-robin load balancing strategy across multiple backup API endpoints to distribute requests evenly and prevent overwhelming any single provider. Each request automatically rotates to the next endpoint in the pool, with automatic fallback to other endpoints if one fails. This ensures high availability and prevents rate limiting by distributing load across multiple providers.
+
 ### Deezer Settings
 
 | Setting | Description |
@@ -282,6 +293,151 @@ Subsonic__EnableExternalPlaylists=false
 
 > **Note**: Due to client-side filtering, playlists from streaming providers may not appear in the "Playlists" tab of some clients, but will show up in global search results.
 
+### Spotify Playlist Injection (Jellyfin Only)
+
+Allstarr can automatically fill your Spotify playlists (like Release Radar and Discover Weekly) with tracks from your configured streaming provider (SquidWTF, Deezer, or Qobuz). This feature works by intercepting playlists created by the Jellyfin Spotify Import plugin and matching missing tracks with your streaming service.
+
+#### Prerequisites
+
+1. **Install the Jellyfin Spotify Import Plugin**
+   - Navigate to Jellyfin Dashboard → Plugins → Catalog
+   - Search for "Spotify Import" by Viperinius
+   - Install and restart Jellyfin
+   - Plugin repository: [Viperinius/jellyfin-plugin-spotify-import](https://github.com/Viperinius/jellyfin-plugin-spotify-import)
+
+2. **Configure the Spotify Import Plugin**
+   - Go to Jellyfin Dashboard → Plugins → Spotify Import
+   - Connect your Spotify account
+   - Select which playlists to sync (e.g., Release Radar, Discover Weekly)
+   - Set a daily sync schedule (e.g., 4:15 PM daily)
+   - The plugin will create playlists in Jellyfin and generate "missing tracks" files for songs not in your library
+
+3. **Configure Allstarr**
+   - Allstarr needs to know when the plugin runs and which playlists to intercept
+   - Uses your existing `JELLYFIN_URL` and `JELLYFIN_API_KEY` settings (no additional credentials needed)
+
+#### Configuration
+
+| Setting | Description |
+|---------|-------------|
+| `SpotifyImport:Enabled` | Enable Spotify playlist injection (default: `false`) |
+| `SpotifyImport:SyncStartHour` | Hour when the Spotify Import plugin runs (24-hour format, 0-23) |
+| `SpotifyImport:SyncStartMinute` | Minute when the plugin runs (0-59) |
+| `SpotifyImport:SyncWindowHours` | Hours to search for missing tracks files after sync time (default: 2) |
+| `SpotifyImport:PlaylistIds` | Comma-separated Jellyfin playlist IDs to intercept |
+| `SpotifyImport:PlaylistNames` | Comma-separated playlist names (must match order of IDs) |
+
+**Environment variables example:**
+```bash
+# Enable the feature
+SPOTIFY_IMPORT_ENABLED=true
+
+# Sync window settings (optional - used to prevent fetching too frequently)
+# The fetcher searches backwards from current time for the last 48 hours
+SPOTIFY_IMPORT_SYNC_START_HOUR=16
+SPOTIFY_IMPORT_SYNC_START_MINUTE=15
+SPOTIFY_IMPORT_SYNC_WINDOW_HOURS=2
+
+# Get playlist IDs from Jellyfin URLs: https://jellyfin.example.com/web/#/details?id=PLAYLIST_ID
+SPOTIFY_IMPORT_PLAYLIST_IDS=ba50e26c867ec9d57ab2f7bf24cfd6b0,4383a46d8bcac3be2ef9385053ea18df
+
+# Names must match exactly as they appear in Jellyfin (used to find missing tracks files)
+SPOTIFY_IMPORT_PLAYLIST_NAMES=Release Radar,Discover Weekly
+```
+
+#### How It Works
+
+1. **Spotify Import Plugin Runs** (e.g., daily at 4:15 PM)
+   - Plugin fetches your Spotify playlists
+   - Creates/updates playlists in Jellyfin with tracks already in your library
+   - Generates "missing tracks" JSON files for songs not found locally
+   - Files are named like: `Release Radar_missing_2026-02-01_16-15.json`
+
+2. **Allstarr Fetches Missing Tracks** (within sync window)
+   - Searches for missing tracks files from the Jellyfin plugin
+   - Searches **+24 hours forward first** (newest files), then **-48 hours backward** if not found
+   - This efficiently finds the most recent file regardless of timezone differences
+   - Example: Server time 12 PM EST, file timestamped 9 PM UTC (same day) → Found in forward search
+   - Caches the list of missing tracks in Redis + file cache
+   - Runs automatically on startup (if needed) and every 5 minutes during the sync window
+
+3. **Allstarr Matches Tracks** (2 minutes after startup, then every 30 minutes)
+   - For each missing track, searches your streaming provider (SquidWTF, Deezer, or Qobuz)
+   - Uses fuzzy matching to find the best match (title + artist similarity)
+   - Rate-limited to avoid overwhelming the service (150ms delay between searches)
+   - Caches matched results for 1 hour
+
+4. **You Open the Playlist in Jellyfin**
+   - Allstarr intercepts the request
+   - Returns a merged list: local tracks + matched streaming tracks
+   - Loads instantly from cache (no searching needed!)
+
+5. **You Play a Track**
+   - If it's a local track, streams from Jellyfin normally
+   - If it's a matched track, downloads from streaming provider on-demand
+   - Downloaded tracks are saved to your library for future use
+
+#### Manual Triggers
+
+You can manually trigger syncing and matching via API:
+
+```bash
+# Fetch missing tracks from Jellyfin plugin
+curl "https://your-jellyfin-proxy.com/spotify/sync?api_key=YOUR_API_KEY"
+
+# Trigger track matching (searches streaming provider)
+curl "https://your-jellyfin-proxy.com/spotify/match?api_key=YOUR_API_KEY"
+
+# Clear cache to force re-matching
+curl "https://your-jellyfin-proxy.com/spotify/clear-cache?api_key=YOUR_API_KEY"
+```
+
+#### Startup Behavior
+
+When Allstarr starts with Spotify Import enabled:
+
+**Smart Cache Check:**
+- Checks if today's sync window has passed (e.g., if sync is at 4 PM + 2 hour window = 6 PM)
+- If before 6 PM and yesterday's cache exists → **Skips fetch** (cache is still current)
+- If after 6 PM or no cache exists → **Fetches missing tracks** from Jellyfin plugin
+
+**Track Matching:**
+- **T+2min**: Matches tracks with streaming provider (with rate limiting)
+- Only matches playlists that don't already have cached matches
+- **Result**: Playlists load instantly when you open them!
+
+**Example Timeline:**
+- Plugin runs daily at 4:15 PM, creates files at ~4:16 PM
+- You restart Allstarr at 12:00 PM (noon) the next day
+- Startup check: "Today's sync window ends at 6 PM, and I have yesterday's 4:16 PM file"
+- **Decision**: Skip fetch, use existing cache
+- At 6:01 PM: Next scheduled check will search for new files
+
+#### Troubleshooting
+
+**Playlists are empty:**
+- Check that the Spotify Import plugin is running and creating playlists
+- Verify `SPOTIFY_IMPORT_PLAYLIST_IDS` match your Jellyfin playlist IDs
+- Check logs: `docker-compose logs -f allstarr | grep -i spotify`
+
+**Tracks aren't matching:**
+- Ensure your streaming provider is configured (`MUSIC_SERVICE`, credentials)
+- Check that playlist names in `SPOTIFY_IMPORT_PLAYLIST_NAMES` match exactly
+- Manually trigger matching: `curl "https://your-proxy.com/spotify/match?api_key=KEY"`
+
+**Sync timing issues:**
+- Set `SPOTIFY_IMPORT_SYNC_START_HOUR/MINUTE` to match your plugin schedule
+- Increase `SPOTIFY_IMPORT_SYNC_WINDOW_HOURS` if files aren't being found
+- Check Jellyfin plugin logs to confirm when it runs
+
+#### Notes
+
+- This feature uses your existing `JELLYFIN_URL` and `JELLYFIN_API_KEY` settings
+- Matched tracks are cached for 1 hour to avoid repeated searches
+- Missing tracks cache persists across restarts (stored in Redis + file cache)
+- Rate limiting prevents overwhelming your streaming provider (150ms between searches)
+- Only works with Jellyfin backend (not Subsonic/Navidrome)
+
 ### Getting Credentials
 
 #### Deezer ARL Token

allstarr.Tests/JellyfinProxyServiceTests.cs

@@ -63,11 +63,12 @@ public class JellyfinProxyServiceTests
         SetupMockResponse(HttpStatusCode.OK, jsonResponse, "application/json");
 
         // Act
-        var result = await _service.GetJsonAsync("Items");
+        var (body, statusCode) = await _service.GetJsonAsync("Items");
 
         // Assert
-        Assert.NotNull(result);
-        Assert.True(result.RootElement.TryGetProperty("Items", out var items));
+        Assert.NotNull(body);
+        Assert.Equal(200, statusCode);
+        Assert.True(body.RootElement.TryGetProperty("Items", out var items));
         Assert.Equal(1, items.GetArrayLength());
     }
 
@@ -78,14 +79,15 @@ public class JellyfinProxyServiceTests
         SetupMockResponse(HttpStatusCode.InternalServerError, "", "text/plain");
 
         // Act
-        var result = await _service.GetJsonAsync("Items");
+        var (body, statusCode) = await _service.GetJsonAsync("Items");
 
         // Assert
-        Assert.Null(result);
+        Assert.Null(body);
+        Assert.Equal(500, statusCode);
     }
 
     [Fact]
-    public async Task GetJsonAsync_IncludesAuthHeader()
+    public async Task GetJsonAsync_WithoutClientHeaders_SendsNoAuth()
     {
         // Arrange
         HttpRequestMessage? captured = null;
@@ -102,13 +104,10 @@ public class JellyfinProxyServiceTests
         // Act
         await _service.GetJsonAsync("Items");
 
-        // Assert
+        // Assert - Should NOT include auth when no client headers provided
         Assert.NotNull(captured);
-        Assert.True(captured!.Headers.Contains("Authorization"));
-        var authHeader = captured.Headers.GetValues("Authorization").First();
-        Assert.Contains("MediaBrowser", authHeader);
-        Assert.Contains(_settings.ApiKey!, authHeader);
-        Assert.Contains(_settings.ClientName!, authHeader);
+        Assert.False(captured!.Headers.Contains("Authorization"));
+        Assert.False(captured.Headers.Contains("X-Emby-Authorization"));
     }
 
     [Fact]
@@ -210,12 +209,13 @@ public class JellyfinProxyServiceTests
             });
 
         // Act
-        var result = await _service.GetItemAsync("abc-123");
+        var (body, statusCode) = await _service.GetItemAsync("abc-123");
 
         // Assert
         Assert.NotNull(captured);
         Assert.Contains("/Items/abc-123", captured!.RequestUri!.ToString());
-        Assert.NotNull(result);
+        Assert.NotNull(body);
+        Assert.Equal(200, statusCode);
     }
 
     [Fact]

allstarr/Controllers/JellyfinController.cs

@@ -10,6 +10,7 @@ using allstarr.Services.Local;
 using allstarr.Services.Jellyfin;
 using allstarr.Services.Subsonic;
 using allstarr.Services.Lyrics;
+using allstarr.Filters;
 
 namespace allstarr.Controllers;
 
@@ -22,34 +23,43 @@ namespace allstarr.Controllers;
 public class JellyfinController : ControllerBase
 {
     private readonly JellyfinSettings _settings;
+    private readonly SpotifyImportSettings _spotifySettings;
     private readonly IMusicMetadataService _metadataService;
     private readonly ILocalLibraryService _localLibraryService;
     private readonly IDownloadService _downloadService;
     private readonly JellyfinResponseBuilder _responseBuilder;
     private readonly JellyfinModelMapper _modelMapper;
     private readonly JellyfinProxyService _proxyService;
+    private readonly JellyfinSessionManager _sessionManager;
     private readonly PlaylistSyncService? _playlistSyncService;
+    private readonly RedisCacheService _cache;
     private readonly ILogger<JellyfinController> _logger;
 
     public JellyfinController(
         IOptions<JellyfinSettings> settings,
+        IOptions<SpotifyImportSettings> spotifySettings,
         IMusicMetadataService metadataService,
         ILocalLibraryService localLibraryService,
         IDownloadService downloadService,
         JellyfinResponseBuilder responseBuilder,
         JellyfinModelMapper modelMapper,
         JellyfinProxyService proxyService,
+        JellyfinSessionManager sessionManager,
+        RedisCacheService cache,
         ILogger<JellyfinController> logger,
         PlaylistSyncService? playlistSyncService = null)
     {
         _settings = settings.Value;
+        _spotifySettings = spotifySettings.Value;
         _metadataService = metadataService;
         _localLibraryService = localLibraryService;
         _downloadService = downloadService;
         _responseBuilder = responseBuilder;
         _modelMapper = modelMapper;
         _proxyService = proxyService;
+        _sessionManager = sessionManager;
         _playlistSyncService = playlistSyncService;
+        _cache = cache;
         _logger = logger;
 
         if (string.IsNullOrWhiteSpace(_settings.Url))
@@ -106,12 +116,25 @@ public class JellyfinController : ControllerBase
                 endpoint = $"{endpoint}{Request.QueryString.Value}";
             }
             
-            var browseResult = await _proxyService.GetJsonAsync(endpoint, null, Request.Headers);
+            var (browseResult, statusCode) = await _proxyService.GetJsonAsync(endpoint, null, Request.Headers);
 
             if (browseResult == null)
             {
-                _logger.LogInformation("Jellyfin returned null - likely 401 Unauthorized, returning 401 to client");
-                return Unauthorized(new { error = "Authentication required" });
+                if (statusCode == 401)
+                {
+                    _logger.LogInformation("Jellyfin returned 401 Unauthorized, returning 401 to client");
+                    return Unauthorized(new { error = "Authentication required" });
+                }
+                
+                _logger.LogInformation("Jellyfin returned {StatusCode}, returning empty result", statusCode);
+                return new JsonResult(new { Items = Array.Empty<object>(), TotalRecordCount = 0, StartIndex = startIndex });
+            }
+
+            // Update Spotify playlist counts if enabled and response contains playlists
+            if (_spotifySettings.Enabled && browseResult.RootElement.TryGetProperty("Items", out var _))
+            {
+                _logger.LogInformation("Browse result has Items, checking for Spotify playlists to update counts");
+                browseResult = await UpdateSpotifyPlaylistCounts(browseResult);
             }
 
             var result = JsonSerializer.Deserialize<object>(browseResult.RootElement.GetRawText());
@@ -154,7 +177,7 @@ public class JellyfinController : ControllerBase
 
         await Task.WhenAll(jellyfinTask, externalTask, playlistTask);
 
-        var jellyfinResult = await jellyfinTask;
+        var (jellyfinResult, _) = await jellyfinTask;
         var externalResult = await externalTask;
         var playlistResult = await playlistTask;
 
@@ -169,31 +192,28 @@ public class JellyfinController : ControllerBase
         var (localSongs, localAlbums, localArtists) = _modelMapper.ParseItemsResponse(jellyfinResult);
 
         // Score and filter Jellyfin results by relevance
-        var scoredLocalSongs = ScoreSearchResults(cleanQuery, localSongs, s => s.Title, s => s.Artist, isExternal: false);
-        var scoredLocalAlbums = ScoreSearchResults(cleanQuery, localAlbums, a => a.Title, a => a.Artist, isExternal: false);
-        var scoredLocalArtists = ScoreSearchResults(cleanQuery, localArtists, a => a.Name, _ => null, isExternal: false);
+        var scoredLocalSongs = ScoreSearchResults(cleanQuery, localSongs, s => s.Title, s => s.Artist, s => s.Album, isExternal: false);
+        var scoredLocalAlbums = ScoreSearchResults(cleanQuery, localAlbums, a => a.Title, a => a.Artist, _ => null, isExternal: false);
+        var scoredLocalArtists = ScoreSearchResults(cleanQuery, localArtists, a => a.Name, _ => null, _ => null, isExternal: false);
 
         // Score external results with a small boost
-        var scoredExternalSongs = ScoreSearchResults(cleanQuery, externalResult.Songs, s => s.Title, s => s.Artist, isExternal: true);
-        var scoredExternalAlbums = ScoreSearchResults(cleanQuery, externalResult.Albums, a => a.Title, a => a.Artist, isExternal: true);
-        var scoredExternalArtists = ScoreSearchResults(cleanQuery, externalResult.Artists, a => a.Name, _ => null, isExternal: true);
+        var scoredExternalSongs = ScoreSearchResults(cleanQuery, externalResult.Songs, s => s.Title, s => s.Artist, s => s.Album, isExternal: true);
+        var scoredExternalAlbums = ScoreSearchResults(cleanQuery, externalResult.Albums, a => a.Title, a => a.Artist, _ => null, isExternal: true);
+        var scoredExternalArtists = ScoreSearchResults(cleanQuery, externalResult.Artists, a => a.Name, _ => null, _ => null, isExternal: true);
 
-        // Merge and sort by score (only include items with score >= 40)
+        // Merge and sort by score (no filtering - just reorder by relevance)
         var allSongs = scoredLocalSongs.Concat(scoredExternalSongs)
-            .Where(x => x.Score >= 40)
             .OrderByDescending(x => x.Score)
             .Select(x => x.Item)
             .ToList();
 
         var allAlbums = scoredLocalAlbums.Concat(scoredExternalAlbums)
-            .Where(x => x.Score >= 40)
             .OrderByDescending(x => x.Score)
             .Select(x => x.Item)
             .ToList();
 
         // Dedupe artists by name, keeping highest scored version
         var artistScores = scoredLocalArtists.Concat(scoredExternalArtists)
-            .Where(x => x.Score >= 40)
             .GroupBy(x => x.Item.Name, StringComparer.OrdinalIgnoreCase)
             .Select(g => g.OrderByDescending(x => x.Score).First())
             .OrderByDescending(x => x.Score)
@@ -210,7 +230,6 @@ public class JellyfinController : ControllerBase
         {
             var scoredPlaylists = playlistResult
                 .Select(p => new { Playlist = p, Score = FuzzyMatcher.CalculateSimilarity(cleanQuery, p.Name) })
-                .Where(x => x.Score >= 40)
                 .OrderByDescending(x => x.Score)
                 .Select(x => _responseBuilder.ConvertPlaylistToJellyfinItem(x.Playlist))
                 .ToList();
@@ -305,7 +324,7 @@ public class JellyfinController : ControllerBase
         }
 
         // Proxy to Jellyfin for local content
-        var result = await _proxyService.GetItemsAsync(
+        var (result, statusCode) = await _proxyService.GetItemsAsync(
             parentId: parentId,
             includeItemTypes: ParseItemTypes(includeItemTypes),
             sortBy: sortBy,
@@ -313,12 +332,7 @@ public class JellyfinController : ControllerBase
             startIndex: startIndex,
             clientHeaders: Request.Headers);
 
-        if (result == null)
-        {
-            return _responseBuilder.CreateError(404, "Parent not found");
-        }
-
-        return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
+        return HandleProxyResponse(result, statusCode);
     }
 
     /// <summary>
@@ -350,7 +364,7 @@ public class JellyfinController : ControllerBase
 
         await Task.WhenAll(jellyfinTask, externalTask);
 
-        var jellyfinResult = await jellyfinTask;
+        var (jellyfinResult, _) = await jellyfinTask;
         var externalResult = await externalTask;
 
         var (localSongs, localAlbums, localArtists) = _modelMapper.ParseItemsResponse(jellyfinResult);
@@ -406,13 +420,9 @@ public class JellyfinController : ControllerBase
         }
 
         // Proxy to Jellyfin
-        var result = await _proxyService.GetItemAsync(itemId, Request.Headers);
-        if (result == null)
-        {
-            return _responseBuilder.CreateError(404, "Item not found");
-        }
-
-        return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
+        var (result, statusCode) = await _proxyService.GetItemAsync(itemId, Request.Headers);
+        
+        return HandleProxyResponse(result, statusCode);
     }
 
     /// <summary>
@@ -524,7 +534,7 @@ public class JellyfinController : ControllerBase
 
             await Task.WhenAll(jellyfinTask, externalTask);
 
-            var jellyfinResult = await jellyfinTask;
+            var (jellyfinResult, _) = await jellyfinTask;
             var externalArtists = await externalTask;
 
             _logger.LogInformation("Artist search results: Jellyfin={JellyfinCount}, External={ExternalCount}",
@@ -574,19 +584,14 @@ public class JellyfinController : ControllerBase
         }
 
         // No search term - just proxy to Jellyfin
-        var result = await _proxyService.GetArtistsAsync(searchTerm, limit, startIndex, Request.Headers);
+        var (result, statusCode) = await _proxyService.GetArtistsAsync(searchTerm, limit, startIndex, Request.Headers);
 
-        if (result == null)
+        return HandleProxyResponse(result, statusCode, new
         {
-            return new JsonResult(new Dictionary<string, object>
-            {
-                ["Items"] = Array.Empty<object>(),
-                ["TotalRecordCount"] = 0,
-                ["StartIndex"] = startIndex
-            });
-        }
-
-        return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
+            Items = Array.Empty<object>(),
+            TotalRecordCount = 0,
+            StartIndex = startIndex
+        });
     }
 
     /// <summary>
@@ -617,10 +622,10 @@ public class JellyfinController : ControllerBase
         }
 
         // Get local artist from Jellyfin
-        var jellyfinArtist = await _proxyService.GetArtistAsync(artistIdOrName, Request.Headers);
+        var (jellyfinArtist, statusCode) = await _proxyService.GetArtistAsync(artistIdOrName, Request.Headers);
         if (jellyfinArtist == null)
         {
-            return _responseBuilder.CreateError(404, "Artist not found");
+            return HandleProxyResponse(null, statusCode);
         }
 
         var artistData = _modelMapper.ParseArtist(jellyfinArtist.RootElement);
@@ -628,7 +633,7 @@ public class JellyfinController : ControllerBase
         var localArtistId = artistData.Id;
 
         // Get local albums
-        var localAlbumsResult = await _proxyService.GetItemsAsync(
+        var (localAlbumsResult, _) = await _proxyService.GetItemsAsync(
             parentId: null,
             includeItemTypes: new[] { "MusicAlbum" },
             sortBy: "SortName",
@@ -778,6 +783,23 @@ public class JellyfinController : ControllerBase
             
             var contentType = response.Content.Headers.ContentType?.ToString() ?? "audio/mpeg";
             
+            // Forward caching headers for client-side caching
+            if (response.Headers.ETag != null)
+            {
+                Response.Headers["ETag"] = response.Headers.ETag.ToString();
+            }
+            
+            if (response.Content.Headers.LastModified.HasValue)
+            {
+                Response.Headers["Last-Modified"] = response.Content.Headers.LastModified.Value.ToString("R");
+            }
+            
+            if (response.Headers.CacheControl != null)
+            {
+                Response.Headers["Cache-Control"] = response.Headers.CacheControl.ToString();
+            }
+            
+            // Forward range headers for seeking
             if (response.Content.Headers.ContentRange != null)
             {
                 Response.Headers["Content-Range"] = response.Content.Headers.ContentRange.ToString();
@@ -845,12 +867,34 @@ public class JellyfinController : ControllerBase
     }
 
     /// <summary>
-    /// Universal audio endpoint that redirects to the stream endpoint.
+    /// Universal audio endpoint - handles transcoding, format negotiation, and adaptive streaming.
+    /// This is the primary endpoint used by Jellyfin Web and most clients.
     /// </summary>
     [HttpGet("Audio/{itemId}/universal")]
-    public Task<IActionResult> UniversalAudio(string itemId)
+    [HttpHead("Audio/{itemId}/universal")]
+    public async Task<IActionResult> UniversalAudio(string itemId)
     {
-        return StreamAudio(itemId);
+        if (string.IsNullOrWhiteSpace(itemId))
+        {
+            return BadRequest(new { error = "Missing item ID" });
+        }
+
+        var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
+
+        if (!isExternal)
+        {
+            // For local content, proxy the universal endpoint with all query parameters
+            var fullPath = $"Audio/{itemId}/universal";
+            if (Request.QueryString.HasValue)
+            {
+                fullPath = $"{fullPath}{Request.QueryString.Value}";
+            }
+
+            return await ProxyJellyfinStream(fullPath, itemId);
+        }
+
+        // For external content, use simple streaming (no transcoding support yet)
+        return await StreamExternalContent(provider!, externalId!);
     }
 
     #endregion
@@ -956,6 +1000,24 @@ public class JellyfinController : ControllerBase
 
         var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
 
+        // For local tracks, check if Jellyfin already has embedded lyrics
+        if (!isExternal)
+        {
+            _logger.LogInformation("Checking Jellyfin for embedded lyrics for local track: {ItemId}", itemId);
+            
+            // Try to get lyrics from Jellyfin first (it reads embedded lyrics from files)
+            var (jellyfinLyrics, statusCode) = await _proxyService.GetJsonAsync($"Audio/{itemId}/Lyrics", null, Request.Headers);
+            
+            if (jellyfinLyrics != null && statusCode == 200)
+            {
+                _logger.LogInformation("✓ Found embedded lyrics in Jellyfin for track {ItemId}", itemId);
+                return new JsonResult(JsonSerializer.Deserialize<object>(jellyfinLyrics.RootElement.GetRawText()));
+            }
+            
+            _logger.LogInformation("No embedded lyrics found in Jellyfin, falling back to LRCLIB search");
+        }
+
+        // For external tracks or when Jellyfin doesn't have lyrics, search LRCLIB
         Song? song = null;
         
         if (isExternal)
@@ -965,7 +1027,7 @@ public class JellyfinController : ControllerBase
         else
         {
             // For local songs, get metadata from Jellyfin
-            var item = await _proxyService.GetItemAsync(itemId, Request.Headers);
+            var (item, _) = await _proxyService.GetItemAsync(itemId, Request.Headers);
             if (item != null && item.RootElement.TryGetProperty("Type", out var typeEl) && 
                 typeEl.GetString() == "Audio")
             {
@@ -985,6 +1047,9 @@ public class JellyfinController : ControllerBase
         }
 
         // Try to get lyrics from LRCLIB
+        _logger.LogInformation("Searching LRCLIB for lyrics: {Artists} - {Title}", 
+            song.Artists.Count > 0 ? string.Join(", ", song.Artists) : song.Artist, 
+            song.Title);
         var lyricsService = HttpContext.RequestServices.GetService<LrclibService>();
         if (lyricsService == null)
         {
@@ -993,7 +1058,7 @@ public class JellyfinController : ControllerBase
 
         var lyrics = await lyricsService.GetLyricsAsync(
             song.Title,
-            song.Artist ?? "",
+            song.Artists.Count > 0 ? song.Artists.ToArray() : new[] { song.Artist ?? "" },
             song.Album ?? "",
             song.Duration ?? 0);
 
@@ -1006,15 +1071,21 @@ public class JellyfinController : ControllerBase
         var lyricsText = lyrics.SyncedLyrics ?? lyrics.PlainLyrics ?? "";
         var isSynced = !string.IsNullOrEmpty(lyrics.SyncedLyrics);
 
+        _logger.LogInformation("Lyrics for {Artist} - {Track}: synced={HasSynced}, plainLength={PlainLen}, syncedLength={SyncLen}", 
+            song.Artist, song.Title, isSynced, lyrics.PlainLyrics?.Length ?? 0, lyrics.SyncedLyrics?.Length ?? 0);
+
         // Parse LRC format into individual lines for Jellyfin
-        var lyricLines = new List<object>();
+        var lyricLines = new List<Dictionary<string, object>>();
         
         if (isSynced && !string.IsNullOrEmpty(lyrics.SyncedLyrics))
         {
+            _logger.LogInformation("Parsing synced lyrics (LRC format)");
             // Parse LRC format: [mm:ss.xx] text
+            // Skip ID tags like [ar:Artist], [ti:Title], etc.
             var lines = lyrics.SyncedLyrics.Split('\n', StringSplitOptions.RemoveEmptyEntries);
             foreach (var line in lines)
             {
+                // Match timestamp format [mm:ss.xx] or [mm:ss.xxx]
                 var match = System.Text.RegularExpressions.Regex.Match(line, @"^\[(\d+):(\d+)\.(\d+)\]\s*(.*)$");
                 if (match.Success)
                 {
@@ -1027,21 +1098,40 @@ public class JellyfinController : ControllerBase
                     var totalMilliseconds = (minutes * 60 + seconds) * 1000 + centiseconds * 10;
                     var ticks = totalMilliseconds * 10000L;
                     
-                    lyricLines.Add(new
+                    // For synced lyrics, include Start timestamp
+                    lyricLines.Add(new Dictionary<string, object>
                     {
-                        Start = ticks,
-                        Text = text
+                        ["Text"] = text,
+                        ["Start"] = ticks
                     });
                 }
+                // Skip ID tags like [ar:Artist], [ti:Title], [length:2:23], etc.
             }
+            _logger.LogInformation("Parsed {Count} synced lyric lines (skipped ID tags)", lyricLines.Count);
+        }
+        else if (!string.IsNullOrEmpty(lyricsText))
+        {
+            _logger.LogInformation("Splitting plain lyrics into lines (no timestamps)");
+            // Plain lyrics - split by newlines and return each line separately
+            // IMPORTANT: Do NOT include "Start" field at all for unsynced lyrics
+            // Including it (even as null) causes clients to treat it as synced with timestamp 0:00
+            var lines = lyricsText.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
+            foreach (var line in lines)
+            {
+                lyricLines.Add(new Dictionary<string, object>
+                {
+                    ["Text"] = line.Trim()
+                });
+            }
+            _logger.LogInformation("Split into {Count} plain lyric lines", lyricLines.Count);
         }
         else
         {
-            // Plain lyrics - return as single block
-            lyricLines.Add(new
+            _logger.LogWarning("No lyrics text available");
+            // No lyrics at all
+            lyricLines.Add(new Dictionary<string, object>
             {
-                Start = (long?)null,
-                Text = lyricsText
+                ["Text"] = ""
             });
         }
 
@@ -1058,6 +1148,17 @@ public class JellyfinController : ControllerBase
             Lyrics = lyricLines
         };
 
+        _logger.LogInformation("Returning lyrics response: {LineCount} lines, synced={IsSynced}", lyricLines.Count, isSynced);
+        
+        // Log a sample of the response for debugging
+        if (lyricLines.Count > 0)
+        {
+            var sampleLine = lyricLines[0];
+            var hasStart = sampleLine.ContainsKey("Start");
+            _logger.LogInformation("Sample line: Text='{Text}', HasStart={HasStart}", 
+                sampleLine.GetValueOrDefault("Text"), hasStart);
+        }
+
         return Ok(response);
     }
 
@@ -1067,10 +1168,21 @@ public class JellyfinController : ControllerBase
 
     /// <summary>
     /// Marks an item as favorite. For playlists, triggers a full download.
+    /// Supports both /Users/{userId}/FavoriteItems/{itemId} and /UserFavoriteItems/{itemId}?userId=xxx
     /// </summary>
     [HttpPost("Users/{userId}/FavoriteItems/{itemId}")]
-    public async Task<IActionResult> MarkFavorite(string userId, string itemId)
+    [HttpPost("UserFavoriteItems/{itemId}")]
+    public async Task<IActionResult> MarkFavorite(string itemId, string? userId = null)
     {
+        // Get userId from query string if not in path
+        if (string.IsNullOrEmpty(userId))
+        {
+            userId = Request.Query["userId"].ToString();
+        }
+        
+        _logger.LogInformation("MarkFavorite called: userId={UserId}, itemId={ItemId}, route={Route}", 
+            userId, itemId, Request.Path);
+        
         // Check if this is an external playlist - trigger download
         if (PlaylistIdHelper.IsExternalPlaylist(itemId))
         {
@@ -1094,97 +1206,102 @@ public class JellyfinController : ControllerBase
                 }
             });
 
-            return Ok(new { IsFavorite = true });
+            // Return a minimal UserItemDataDto response
+            return Ok(new 
+            { 
+                IsFavorite = true,
+                ItemId = itemId
+            });
         }
 
         // Check if this is an external song/album
-        var (isExternal, _, _) = _localLibraryService.ParseSongId(itemId);
+        var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
         if (isExternal)
         {
-            // External items don't exist in Jellyfin, so we can't favorite them there
-            // Just return success - the client will show it as favorited
-            _logger.LogDebug("Favoriting external item {ItemId} (not synced to Jellyfin)", itemId);
-            return Ok(new { IsFavorite = true });
+            _logger.LogInformation("Favoriting external item {ItemId}, copying to kept folder", itemId);
+            
+            // Copy the track to kept folder in background
+            _ = Task.Run(async () =>
+            {
+                try
+                {
+                    await CopyExternalTrackToKeptAsync(itemId, provider!, externalId!);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Failed to copy external track {ItemId} to kept folder", itemId);
+                }
+            });
+            
+            // Return a minimal UserItemDataDto response
+            return Ok(new 
+            { 
+                IsFavorite = true,
+                ItemId = itemId
+            });
         }
 
         // For local Jellyfin items, proxy the request through
-        var endpoint = $"Users/{userId}/FavoriteItems/{itemId}";
+        // Use the official Jellyfin endpoint format
+        var endpoint = $"UserFavoriteItems/{itemId}";
+        if (!string.IsNullOrEmpty(userId))
+        {
+            endpoint = $"{endpoint}?userId={userId}";
+        }
         
-        try
-        {
-            using var request = new HttpRequestMessage(HttpMethod.Post, $"{_settings.Url?.TrimEnd('/')}/{endpoint}");
-            
-            // Forward client authentication
-            if (Request.Headers.TryGetValue("X-Emby-Authorization", out var embyAuth))
-            {
-                request.Headers.TryAddWithoutValidation("X-Emby-Authorization", embyAuth.ToString());
-            }
-            else if (Request.Headers.TryGetValue("Authorization", out var auth))
-            {
-                request.Headers.TryAddWithoutValidation("Authorization", auth.ToString());
-            }
-            
-            var response = await _proxyService.HttpClient.SendAsync(request);
-            
-            if (response.IsSuccessStatusCode)
-            {
-                return Ok(new { IsFavorite = true });
-            }
-            
-            _logger.LogWarning("Failed to favorite item in Jellyfin: {StatusCode}", response.StatusCode);
-            return _responseBuilder.CreateError((int)response.StatusCode, "Failed to mark favorite");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error favoriting item {ItemId}", itemId);
-            return _responseBuilder.CreateError(500, "Failed to mark favorite");
-        }
+        _logger.LogInformation("Proxying favorite request to Jellyfin: {Endpoint}", endpoint);
+        
+        var (result, statusCode) = await _proxyService.PostJsonAsync(endpoint, "{}", Request.Headers);
+        
+        return HandleProxyResponse(result, statusCode);
     }
 
     /// <summary>
     /// Removes an item from favorites.
+    /// Supports both /Users/{userId}/FavoriteItems/{itemId} and /UserFavoriteItems/{itemId}?userId=xxx
     /// </summary>
     [HttpDelete("Users/{userId}/FavoriteItems/{itemId}")]
-    public async Task<IActionResult> UnmarkFavorite(string userId, string itemId)
+    [HttpDelete("UserFavoriteItems/{itemId}")]
+    public async Task<IActionResult> UnmarkFavorite(string itemId, string? userId = null)
     {
-        // External items can't be unfavorited
+        // Get userId from query string if not in path
+        if (string.IsNullOrEmpty(userId))
+        {
+            userId = Request.Query["userId"].ToString();
+        }
+        
+        _logger.LogInformation("UnmarkFavorite called: userId={UserId}, itemId={ItemId}, route={Route}", 
+            userId, itemId, Request.Path);
+        
+        // External items can't be unfavorited (they're not really favorited in Jellyfin)
         var (isExternal, _, _) = _localLibraryService.ParseSongId(itemId);
         if (isExternal || PlaylistIdHelper.IsExternalPlaylist(itemId))
         {
-            return Ok(new { IsFavorite = false });
+            _logger.LogInformation("Unfavoriting external item {ItemId} - returning success", itemId);
+            return Ok(new 
+            { 
+                IsFavorite = false,
+                ItemId = itemId
+            });
         }
 
         // Proxy to Jellyfin to unfavorite
-        var url = $"Users/{userId}/FavoriteItems/{itemId}";
+        // Use the official Jellyfin endpoint format
+        var endpoint = $"UserFavoriteItems/{itemId}";
+        if (!string.IsNullOrEmpty(userId))
+        {
+            endpoint = $"{endpoint}?userId={userId}";
+        }
         
-        try
-        {
-            using var request = new HttpRequestMessage(HttpMethod.Delete, $"{_settings.Url?.TrimEnd('/')}/{url}");
-            
-            // Forward client authentication
-            if (Request.Headers.TryGetValue("X-Emby-Authorization", out var embyAuth))
-            {
-                request.Headers.TryAddWithoutValidation("X-Emby-Authorization", embyAuth.ToString());
-            }
-            else if (Request.Headers.TryGetValue("Authorization", out var auth))
-            {
-                request.Headers.TryAddWithoutValidation("Authorization", auth.ToString());
-            }
-            
-            var response = await _proxyService.HttpClient.SendAsync(request);
-            
-            if (response.IsSuccessStatusCode)
-            {
-                return Ok(new { IsFavorite = false });
-            }
-            
-            return _responseBuilder.CreateError(500, "Failed to unfavorite item");
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error unfavoriting item {ItemId}", itemId);
-            return _responseBuilder.CreateError(500, "Failed to unfavorite item");
-        }
+        _logger.LogInformation("Proxying unfavorite request to Jellyfin: {Endpoint}", endpoint);
+        
+        var (result, statusCode) = await _proxyService.DeleteAsync(endpoint, Request.Headers);
+        
+        return HandleProxyResponse(result, statusCode, new 
+        { 
+            IsFavorite = false,
+            ItemId = itemId
+        });
     }
 
     #endregion
@@ -1238,10 +1355,50 @@ public class JellyfinController : ControllerBase
     {
         try
         {
-            var (provider, externalId) = PlaylistIdHelper.ParsePlaylistId(playlistId);
-            var tracks = await _metadataService.GetPlaylistTracksAsync(provider, externalId);
+            _logger.LogInformation("=== GetPlaylistTracks called === PlaylistId: {PlaylistId}", playlistId);
+            
+            // Check if this is an external playlist (Deezer/Qobuz) first
+            if (PlaylistIdHelper.IsExternalPlaylist(playlistId))
+            {
+                var (provider, externalId) = PlaylistIdHelper.ParsePlaylistId(playlistId);
+                var tracks = await _metadataService.GetPlaylistTracksAsync(provider, externalId);
+                return _responseBuilder.CreateItemsResponse(tracks);
+            }
 
-            return _responseBuilder.CreateItemsResponse(tracks);
+            // Check if this is a Spotify playlist (by ID)
+            _logger.LogInformation("Spotify Import Enabled: {Enabled}, Configured Playlists: {Count}", 
+                _spotifySettings.Enabled, _spotifySettings.Playlists.Count);
+            
+            if (_spotifySettings.Enabled && _spotifySettings.IsSpotifyPlaylist(playlistId))
+            {
+                // Get playlist info from Jellyfin to get the name for matching missing tracks
+                _logger.LogInformation("Fetching playlist info from Jellyfin for ID: {PlaylistId}", playlistId);
+                var (playlistInfo, _) = await _proxyService.GetJsonAsync($"Items/{playlistId}", null, Request.Headers);
+                
+                if (playlistInfo != null && playlistInfo.RootElement.TryGetProperty("Name", out var nameElement))
+                {
+                    var playlistName = nameElement.GetString() ?? "";
+                    _logger.LogInformation("✓ MATCHED! Intercepting Spotify playlist: {PlaylistName} (ID: {PlaylistId})", 
+                        playlistName, playlistId);
+                    return await GetSpotifyPlaylistTracksAsync(playlistName, playlistId);
+                }
+                else
+                {
+                    _logger.LogWarning("Could not get playlist name from Jellyfin for ID: {PlaylistId}", playlistId);
+                }
+            }
+
+            // Regular Jellyfin playlist - proxy through
+            var endpoint = $"Playlists/{playlistId}/Items";
+            if (Request.QueryString.HasValue)
+            {
+                endpoint = $"{endpoint}{Request.QueryString.Value}";
+            }
+            
+            _logger.LogInformation("Proxying to Jellyfin: {Endpoint}", endpoint);
+            var (result, statusCode) = await _proxyService.GetJsonAsync(endpoint, null, Request.Headers);
+            
+            return HandleProxyResponse(result, statusCode);
         }
         catch (Exception ex)
         {
@@ -1309,15 +1466,51 @@ public class JellyfinController : ControllerBase
             // DO NOT log request body or detailed headers - contains password
             
             // Forward to Jellyfin server with client headers
-            var result = await _proxyService.PostJsonAsync("Users/AuthenticateByName", body, Request.Headers);
+            var (result, statusCode) = await _proxyService.PostJsonAsync("Users/AuthenticateByName", body, Request.Headers);
             
             if (result == null)
             {
-                _logger.LogWarning("Authentication failed - no response from Jellyfin");
-                return Unauthorized(new { error = "Authentication failed" });
+                _logger.LogWarning("Authentication failed - status {StatusCode}", statusCode);
+                if (statusCode == 401)
+                {
+                    return Unauthorized(new { error = "Invalid username or password" });
+                }
+                return StatusCode(statusCode, new { error = "Authentication failed" });
             }
             
             _logger.LogInformation("Authentication successful");
+            
+            // Post session capabilities immediately after authentication
+            // This ensures Jellyfin creates a session that will show up in the dashboard
+            try
+            {
+                _logger.LogInformation("🔧 Posting session capabilities after authentication");
+                var capabilities = new
+                {
+                    PlayableMediaTypes = new[] { "Audio" },
+                    SupportedCommands = Array.Empty<string>(),
+                    SupportsMediaControl = false,
+                    SupportsPersistentIdentifier = true,
+                    SupportsSync = false
+                };
+                
+                var capabilitiesJson = JsonSerializer.Serialize(capabilities);
+                var (capResult, capStatus) = await _proxyService.PostJsonAsync("Sessions/Capabilities/Full", capabilitiesJson, Request.Headers);
+                
+                if (capStatus == 204 || capStatus == 200)
+                {
+                    _logger.LogInformation("✓ Session capabilities posted after auth ({StatusCode})", capStatus);
+                }
+                else
+                {
+                    _logger.LogWarning("⚠ Session capabilities returned {StatusCode} after auth", capStatus);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to post session capabilities after auth, continuing anyway");
+            }
+            
             return Content(result.RootElement.GetRawText(), "application/json");
         }
         catch (Exception ex)
@@ -1421,18 +1614,9 @@ public class JellyfinController : ControllerBase
             queryParams["userId"] = userId;
         }
 
-        var result = await _proxyService.GetJsonAsync(endpoint, queryParams, Request.Headers);
+        var (result, statusCode) = await _proxyService.GetJsonAsync(endpoint, queryParams, Request.Headers);
         
-        if (result == null)
-        {
-            return _responseBuilder.CreateJsonResponse(new
-            {
-                Items = Array.Empty<object>(),
-                TotalRecordCount = 0
-            });
-        }
-
-        return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
+        return HandleProxyResponse(result, statusCode, new { Items = Array.Empty<object>(), TotalRecordCount = 0 });
     }
 
     /// <summary>
@@ -1535,22 +1719,427 @@ public class JellyfinController : ControllerBase
             queryParams["userId"] = userId;
         }
 
-        var result = await _proxyService.GetJsonAsync($"Songs/{itemId}/InstantMix", queryParams, Request.Headers);
+        var (result, statusCode) = await _proxyService.GetJsonAsync($"Songs/{itemId}/InstantMix", queryParams, Request.Headers);
         
-        if (result == null)
-        {
-            return _responseBuilder.CreateJsonResponse(new
-            {
-                Items = Array.Empty<object>(),
-                TotalRecordCount = 0
-            });
-        }
-
-        return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
+        return HandleProxyResponse(result, statusCode, new { Items = Array.Empty<object>(), TotalRecordCount = 0 });
     }
 
     #endregion
 
+    #region Playback Session Reporting
+
+    #region Session Management
+
+    /// <summary>
+    /// Reports session capabilities. Required for Jellyfin to track active sessions.
+    /// Handles both POST (with body) and GET (query params only) methods.
+    /// </summary>
+    [HttpPost("Sessions/Capabilities")]
+    [HttpPost("Sessions/Capabilities/Full")]
+    [HttpGet("Sessions/Capabilities")]
+    [HttpGet("Sessions/Capabilities/Full")]
+    public async Task<IActionResult> ReportCapabilities()
+    {
+        try
+        {
+            var method = Request.Method;
+            var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : "";
+            
+            _logger.LogInformation("📡 Session capabilities reported - Method: {Method}, Query: {Query}", method, queryString);
+            _logger.LogInformation("Headers: {Headers}", 
+                string.Join(", ", Request.Headers.Where(h => h.Key.Contains("Auth", StringComparison.OrdinalIgnoreCase) || h.Key.Contains("Device", StringComparison.OrdinalIgnoreCase) || h.Key.Contains("Client", StringComparison.OrdinalIgnoreCase))
+                    .Select(h => $"{h.Key}={h.Value}")));
+            
+            // Forward to Jellyfin with query string and headers
+            var endpoint = $"Sessions/Capabilities{queryString}";
+            
+            // Read body if present (POST requests)
+            string body = "{}";
+            if (method == "POST" && Request.ContentLength > 0)
+            {
+                Request.EnableBuffering();
+                using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
+                {
+                    body = await reader.ReadToEndAsync();
+                }
+                Request.Body.Position = 0;
+                _logger.LogInformation("Capabilities body: {Body}", body);
+            }
+            
+            var (result, statusCode) = await _proxyService.PostJsonAsync(endpoint, body, Request.Headers);
+            
+            if (statusCode == 204 || statusCode == 200)
+            {
+                _logger.LogInformation("✓ Session capabilities forwarded to Jellyfin ({StatusCode})", statusCode);
+            }
+            else
+            {
+                _logger.LogWarning("⚠ Jellyfin returned {StatusCode} for capabilities", statusCode);
+            }
+            
+            return NoContent();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to report session capabilities");
+            return StatusCode(500);
+        }
+    }
+
+    /// <summary>
+    /// Reports playback start. Handles both local and external tracks.
+    /// For local tracks, forwards to Jellyfin. For external tracks, logs locally.
+    /// Also ensures session is initialized if this is the first report from a device.
+    /// </summary>
+    [HttpPost("Sessions/Playing")]
+    public async Task<IActionResult> ReportPlaybackStart()
+    {
+        try
+        {
+            Request.EnableBuffering();
+            string body;
+            using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
+            {
+                body = await reader.ReadToEndAsync();
+            }
+            Request.Body.Position = 0;
+
+            _logger.LogInformation("📻 Playback START reported");
+
+            // Parse the body to check if it's an external track
+            var doc = JsonDocument.Parse(body);
+            string? itemId = null;
+            string? itemName = null;
+            
+            if (doc.RootElement.TryGetProperty("ItemId", out var itemIdProp))
+            {
+                itemId = itemIdProp.GetString();
+            }
+            
+            if (doc.RootElement.TryGetProperty("ItemName", out var itemNameProp))
+            {
+                itemName = itemNameProp.GetString();
+            }
+
+            if (!string.IsNullOrEmpty(itemId))
+            {
+                var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
+
+                if (isExternal)
+                {
+                    _logger.LogInformation("🎵 External track playback started: {Name} ({Provider}/{ExternalId})", 
+                        itemName ?? "Unknown", provider, externalId);
+                    // For external tracks, we can't report to Jellyfin since it doesn't know about them
+                    // Just return success so the client is happy
+                    return NoContent();
+                }
+                
+                _logger.LogInformation("🎵 Local track playback started: {Name} (ID: {ItemId})", 
+                    itemName ?? "Unknown", itemId);
+            }
+
+            // For local tracks, forward playback start to Jellyfin FIRST
+            _logger.LogInformation("Forwarding playback start to Jellyfin...");
+            
+            // Fetch full item details to include in playback report
+            try
+            {
+                var (itemResult, itemStatus) = await _proxyService.GetJsonAsync($"Items/{itemId}", null, Request.Headers);
+                if (itemResult != null && itemStatus == 200)
+                {
+                    var item = itemResult.RootElement;
+                    _logger.LogInformation("📦 Fetched item details for playback report");
+                    
+                    // Build playback start info - Jellyfin will fetch item details itself
+                    var playbackStart = new
+                    {
+                        ItemId = itemId,
+                        PositionTicks = doc.RootElement.TryGetProperty("PositionTicks", out var posProp) ? posProp.GetInt64() : 0,
+                        // Let Jellyfin fetch the item details - don't include NowPlayingItem
+                    };
+                    
+                    var playbackJson = JsonSerializer.Serialize(playbackStart);
+                    _logger.LogInformation("📤 Sending playback start: {Json}", playbackJson);
+                    
+                    var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing", playbackJson, Request.Headers);
+                    
+                    if (statusCode == 204 || statusCode == 200)
+                    {
+                        _logger.LogInformation("✓ Playback start forwarded to Jellyfin ({StatusCode})", statusCode);
+                        
+                        // NOW ensure session exists with capabilities (after playback is reported)
+                        var (deviceId, client, device, version) = ExtractDeviceInfo(Request.Headers);
+                        if (!string.IsNullOrEmpty(deviceId))
+                        {
+                            var sessionCreated = await _sessionManager.EnsureSessionAsync(deviceId, client ?? "Unknown", device ?? "Unknown", version ?? "1.0", Request.Headers);
+                            if (sessionCreated)
+                            {
+                                _logger.LogWarning("✓ SESSION: Session ensured for device {DeviceId} after playback start", deviceId);
+                            }
+                            else
+                            {
+                                _logger.LogWarning("⚠️ SESSION: Failed to ensure session for device {DeviceId}", deviceId);
+                            }
+                        }
+                        else
+                        {
+                            _logger.LogWarning("⚠️ SESSION: No device ID found in headers for playback start");
+                        }
+                    }
+                    else
+                    {
+                        _logger.LogWarning("⚠️  Playback start returned status {StatusCode}", statusCode);
+                    }
+                }
+                else
+                {
+                    _logger.LogWarning("⚠️  Could not fetch item details ({StatusCode}), sending basic playback start", itemStatus);
+                    // Fall back to basic playback start
+                    var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing", body, Request.Headers);
+                    if (statusCode == 204 || statusCode == 200)
+                    {
+                        _logger.LogInformation("✓ Basic playback start forwarded to Jellyfin ({StatusCode})", statusCode);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to send playback start, trying basic");
+                // Fall back to basic playback start
+                var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing", body, Request.Headers);
+                if (statusCode == 204 || statusCode == 200)
+                {
+                    _logger.LogInformation("✓ Basic playback start forwarded to Jellyfin ({StatusCode})", statusCode);
+                }
+            }
+            
+            return NoContent();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to report playback start");
+            return NoContent(); // Return success anyway to not break playback
+        }
+    }
+
+    /// <summary>
+    /// Reports playback progress. Handles both local and external tracks.
+    /// </summary>
+    [HttpPost("Sessions/Playing/Progress")]
+    public async Task<IActionResult> ReportPlaybackProgress()
+    {
+        try
+        {
+            Request.EnableBuffering();
+            string body;
+            using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
+            {
+                body = await reader.ReadToEndAsync();
+            }
+            Request.Body.Position = 0;
+
+            // Update session activity
+            var (deviceId, _, _, _) = ExtractDeviceInfo(Request.Headers);
+            if (!string.IsNullOrEmpty(deviceId))
+            {
+                _sessionManager.UpdateActivity(deviceId);
+            }
+
+            // Parse the body to check if it's an external track
+            var doc = JsonDocument.Parse(body);
+            if (doc.RootElement.TryGetProperty("ItemId", out var itemIdProp))
+            {
+                var itemId = itemIdProp.GetString();
+                var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId ?? "");
+
+                if (isExternal)
+                {
+                    // For external tracks, just acknowledge
+                    return NoContent();
+                }
+            }
+
+            // For local tracks, forward to Jellyfin
+            var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing/Progress", body, Request.Headers);
+            return NoContent();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to report playback progress");
+            return NoContent();
+        }
+    }
+
+    /// <summary>
+    /// Reports playback stopped. Handles both local and external tracks.
+    /// </summary>
+    [HttpPost("Sessions/Playing/Stopped")]
+    public async Task<IActionResult> ReportPlaybackStopped()
+    {
+        try
+        {
+            Request.EnableBuffering();
+            string body;
+            using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
+            {
+                body = await reader.ReadToEndAsync();
+            }
+            Request.Body.Position = 0;
+
+            _logger.LogInformation("⏹️  Playback STOPPED reported");
+
+            // Parse the body to check if it's an external track
+            var doc = JsonDocument.Parse(body);
+            string? itemId = null;
+            string? itemName = null;
+            long? positionTicks = null;
+            
+            if (doc.RootElement.TryGetProperty("ItemId", out var itemIdProp))
+            {
+                itemId = itemIdProp.GetString();
+            }
+            
+            if (doc.RootElement.TryGetProperty("ItemName", out var itemNameProp))
+            {
+                itemName = itemNameProp.GetString();
+            }
+            
+            if (doc.RootElement.TryGetProperty("PositionTicks", out var posProp))
+            {
+                positionTicks = posProp.GetInt64();
+            }
+
+            if (!string.IsNullOrEmpty(itemId))
+            {
+                var (isExternal, provider, externalId) = _localLibraryService.ParseSongId(itemId);
+
+                if (isExternal)
+                {
+                    var position = positionTicks.HasValue 
+                        ? TimeSpan.FromTicks(positionTicks.Value).ToString(@"mm\:ss")
+                        : "unknown";
+                    _logger.LogInformation("🎵 External track playback stopped: {Name} at {Position} ({Provider}/{ExternalId})", 
+                        itemName ?? "Unknown", position, provider, externalId);
+                    return NoContent();
+                }
+                
+                _logger.LogInformation("🎵 Local track playback stopped: {Name} (ID: {ItemId})", 
+                    itemName ?? "Unknown", itemId);
+            }
+
+            // For local tracks, forward to Jellyfin
+            _logger.LogInformation("Forwarding playback stop to Jellyfin...");
+            var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Playing/Stopped", body, Request.Headers);
+            
+            if (statusCode == 204 || statusCode == 200)
+            {
+                _logger.LogInformation("✓ Playback stop forwarded to Jellyfin ({StatusCode})", statusCode);
+            }
+            else
+            {
+                _logger.LogWarning("Playback stop forward failed with status {StatusCode}", statusCode);
+            }
+            
+            return NoContent();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to report playback stopped");
+            return NoContent();
+        }
+    }
+
+    /// <summary>
+    /// Pings a playback session to keep it alive.
+    /// </summary>
+    [HttpPost("Sessions/Playing/Ping")]
+    public async Task<IActionResult> PingPlaybackSession([FromQuery] string playSessionId)
+    {
+        try
+        {
+            _logger.LogDebug("Playback session ping: {SessionId}", playSessionId);
+            
+            // Forward to Jellyfin
+            var endpoint = $"Sessions/Playing/Ping?playSessionId={Uri.EscapeDataString(playSessionId)}";
+            var (result, statusCode) = await _proxyService.PostJsonAsync(endpoint, "{}", Request.Headers);
+            return NoContent();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to ping playback session");
+            return NoContent();
+        }
+    }
+
+    /// <summary>
+    /// Catch-all for any other session-related requests.
+    /// <summary>
+    /// Catch-all proxy for any other session-related endpoints we haven't explicitly implemented.
+    /// This ensures all session management calls get proxied to Jellyfin.
+    /// Examples: GET /Sessions, POST /Sessions/Logout, etc.
+    /// </summary>
+    [HttpGet("Sessions")]
+    [HttpPost("Sessions")]
+    [HttpGet("Sessions/{**path}")]
+    [HttpPost("Sessions/{**path}")]
+    [HttpPut("Sessions/{**path}")]
+    [HttpDelete("Sessions/{**path}")]
+    public async Task<IActionResult> ProxySessionRequest(string? path = null)
+    {
+        try
+        {
+            var method = Request.Method;
+            var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : "";
+            var endpoint = string.IsNullOrEmpty(path) ? $"Sessions{queryString}" : $"Sessions/{path}{queryString}";
+            
+            _logger.LogInformation("🔄 Proxying session request: {Method} {Endpoint}", method, endpoint);
+            _logger.LogDebug("Session proxy headers: {Headers}", 
+                string.Join(", ", Request.Headers.Where(h => h.Key.Contains("Auth", StringComparison.OrdinalIgnoreCase))
+                    .Select(h => $"{h.Key}={h.Value}")));
+            
+            // Read body if present
+            string body = "{}";
+            if ((method == "POST" || method == "PUT") && Request.ContentLength > 0)
+            {
+                Request.EnableBuffering();
+                using (var reader = new StreamReader(Request.Body, System.Text.Encoding.UTF8, detectEncodingFromByteOrderMarks: false, bufferSize: 1024, leaveOpen: true))
+                {
+                    body = await reader.ReadToEndAsync();
+                }
+                Request.Body.Position = 0;
+                _logger.LogDebug("Session proxy body: {Body}", body);
+            }
+            
+            // Forward to Jellyfin
+            var (result, statusCode) = method switch
+            {
+                "GET" => await _proxyService.GetJsonAsync(endpoint, null, Request.Headers),
+                "POST" => await _proxyService.PostJsonAsync(endpoint, body, Request.Headers),
+                "PUT" => await _proxyService.PostJsonAsync(endpoint, body, Request.Headers), // Use POST for PUT
+                "DELETE" => await _proxyService.PostJsonAsync(endpoint, body, Request.Headers), // Use POST for DELETE
+                _ => (null, 405)
+            };
+            
+            if (result != null)
+            {
+                _logger.LogInformation("✓ Session request proxied successfully ({StatusCode})", statusCode);
+                return new JsonResult(result.RootElement.Clone());
+            }
+            
+            _logger.LogInformation("✓ Session request proxied ({StatusCode}, no body)", statusCode);
+            return StatusCode(statusCode);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to proxy session request: {Path}", path);
+            return StatusCode(500);
+        }
+    }
+
+    #endregion // Session Management
+
+    #endregion // Playback Session Reporting
+
     #region System & Proxy
 
     /// <summary>
@@ -1585,11 +2174,88 @@ public class JellyfinController : ControllerBase
     /// <summary>
     /// Catch-all endpoint that proxies unhandled requests to Jellyfin transparently.
     /// This route has the lowest priority and should only match requests that don't have SearchTerm.
+    /// Blocks dangerous admin endpoints for security.
     /// </summary>
     [HttpGet("{**path}", Order = 100)]
     [HttpPost("{**path}", Order = 100)]
     public async Task<IActionResult> ProxyRequest(string path)
     {
+        // Log session-related requests prominently to debug missing capabilities call
+        if (path.Contains("session", StringComparison.OrdinalIgnoreCase) || 
+            path.Contains("capabilit", StringComparison.OrdinalIgnoreCase))
+        {
+            _logger.LogWarning("🔍 SESSION/CAPABILITY REQUEST: {Method} /{Path}{Query}", Request.Method, path, Request.QueryString);
+        }
+        else
+        {
+            _logger.LogDebug("ProxyRequest: {Method} /{Path}", Request.Method, path);
+        }
+        
+        // Log endpoint usage to file for analysis
+        await LogEndpointUsageAsync(path, Request.Method);
+        
+        // Block dangerous admin endpoints
+        var blockedPrefixes = new[]
+        {
+            "system/restart",           // Server restart
+            "system/shutdown",          // Server shutdown
+            "system/configuration",     // System configuration changes
+            "system/logs",              // Server logs access
+            "system/activitylog",       // Activity log access
+            "plugins/",                 // Plugin management (install/uninstall/configure)
+            "scheduledtasks/",          // Scheduled task management
+            "startup/",                 // Initial server setup
+            "users/new",                // User creation
+            "library/refresh",          // Library scan (expensive operation)
+            "library/virtualfolders",   // Library folder management
+            "branding/",                // Branding configuration
+            "displaypreferences/",      // Display preferences (if not user-specific)
+            "notifications/admin"       // Admin notifications
+        };
+        
+        // Check if path matches any blocked prefix
+        if (blockedPrefixes.Any(prefix => 
+            path.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)))
+        {
+            _logger.LogWarning("BLOCKED: Access denied to admin endpoint: {Path} from {IP}", 
+                path, 
+                HttpContext.Connection.RemoteIpAddress);
+            return StatusCode(403, new 
+            { 
+                error = "Access to administrative endpoints is not allowed through this proxy",
+                path = path
+            });
+        }
+        
+        // Intercept Spotify playlist requests by ID
+        if (_spotifySettings.Enabled && 
+            path.StartsWith("playlists/", StringComparison.OrdinalIgnoreCase) && 
+            path.Contains("/items", StringComparison.OrdinalIgnoreCase))
+        {
+            // Extract playlist ID from path: playlists/{id}/items
+            var parts = path.Split('/', StringSplitOptions.RemoveEmptyEntries);
+            if (parts.Length >= 2 && parts[0].Equals("playlists", StringComparison.OrdinalIgnoreCase))
+            {
+                var playlistId = parts[1];
+                
+                _logger.LogInformation("=== PLAYLIST REQUEST ===");
+                _logger.LogInformation("Playlist ID: {PlaylistId}", playlistId);
+                _logger.LogInformation("Spotify Enabled: {Enabled}", _spotifySettings.Enabled);
+                _logger.LogInformation("Configured Playlists: {Playlists}", string.Join(", ", _spotifySettings.Playlists.Select(p => $"{p.Name}:{p.Id}")));
+                _logger.LogInformation("Is configured: {IsConfigured}", _spotifySettings.IsSpotifyPlaylist(playlistId));
+                
+                // Check if this playlist ID is configured for Spotify injection
+                if (_spotifySettings.IsSpotifyPlaylist(playlistId))
+                {
+                    _logger.LogInformation("========================================");
+                    _logger.LogInformation("=== INTERCEPTING SPOTIFY PLAYLIST ===");
+                    _logger.LogInformation("Playlist ID: {PlaylistId}", playlistId);
+                    _logger.LogInformation("========================================");
+                    return await GetPlaylistTracks(playlistId);
+                }
+            }
+        }
+        
         // Handle non-JSON responses (robots.txt, etc.)
         if (path.EndsWith(".txt", StringComparison.OrdinalIgnoreCase) || 
             path.EndsWith(".xml", StringComparison.OrdinalIgnoreCase))
@@ -1659,6 +2325,7 @@ public class JellyfinController : ControllerBase
             }
             
             JsonDocument? result;
+            int statusCode;
             
             if (HttpContext.Request.Method == HttpMethod.Post.Method)
             {
@@ -1700,22 +2367,59 @@ public class JellyfinController : ControllerBase
                     }
                 }
                 
-                result = await _proxyService.PostJsonAsync(fullPath, body, Request.Headers);
+                (result, statusCode) = await _proxyService.PostJsonAsync(fullPath, body, Request.Headers);
             }
             else
             {
                 // Forward GET requests transparently with authentication headers and query string
-                result = await _proxyService.GetJsonAsync(fullPath, null, Request.Headers);
+                (result, statusCode) = await _proxyService.GetJsonAsync(fullPath, null, Request.Headers);
             }
             
+            // Handle different status codes
             if (result == null)
             {
-                // Return 204 No Content for successful requests with no body
-                // (e.g., /sessions/playing, /sessions/playing/progress)
+                // No body - return the status code from Jellyfin
+                if (statusCode == 204)
+                {
+                    return NoContent();
+                }
+                else if (statusCode == 401)
+                {
+                    return Unauthorized();
+                }
+                else if (statusCode == 403)
+                {
+                    return Forbid();
+                }
+                else if (statusCode == 404)
+                {
+                    return NotFound();
+                }
+                else if (statusCode >= 400 && statusCode < 500)
+                {
+                    return StatusCode(statusCode);
+                }
+                else if (statusCode >= 500)
+                {
+                    return StatusCode(statusCode);
+                }
+                
+                // Default to 204 for 2xx responses with no body
                 return NoContent();
             }
 
-            return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
+            // Modify response if it contains Spotify playlists to update ChildCount
+            // Only check for Items if the response is an object (not a string or array)
+            if (_spotifySettings.Enabled && 
+                result.RootElement.ValueKind == JsonValueKind.Object && 
+                result.RootElement.TryGetProperty("Items", out var items))
+            {
+                _logger.LogInformation("Response has Items property, checking for Spotify playlists to update counts");
+                result = await UpdateSpotifyPlaylistCounts(result);
+            }
+
+            // Return the raw JSON element directly to avoid deserialization issues with simple types
+            return new JsonResult(result.RootElement.Clone());
         }
         catch (Exception ex)
         {
@@ -1728,6 +2432,207 @@ public class JellyfinController : ControllerBase
 
     #region Helpers
 
+    /// <summary>
+    /// Helper to handle proxy responses with proper status code handling.
+    /// </summary>
+    private IActionResult HandleProxyResponse(JsonDocument? result, int statusCode, object? fallbackValue = null)
+    {
+        if (result != null)
+        {
+            return new JsonResult(JsonSerializer.Deserialize<object>(result.RootElement.GetRawText()));
+        }
+        
+        // Handle error status codes
+        if (statusCode == 401)
+        {
+            return Unauthorized();
+        }
+        else if (statusCode == 403)
+        {
+            return Forbid();
+        }
+        else if (statusCode == 404)
+        {
+            return NotFound();
+        }
+        else if (statusCode >= 400)
+        {
+            return StatusCode(statusCode);
+        }
+        
+        // Success with no body - return fallback or empty
+        if (fallbackValue != null)
+        {
+            return new JsonResult(fallbackValue);
+        }
+        
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Updates ChildCount for Spotify playlists in the response to show total tracks (local + matched).
+    /// </summary>
+    private async Task<JsonDocument> UpdateSpotifyPlaylistCounts(JsonDocument response)
+    {
+        try
+        {
+            if (!response.RootElement.TryGetProperty("Items", out var items))
+            {
+                return response;
+            }
+
+            var itemsArray = items.EnumerateArray().ToList();
+            var modified = false;
+            var updatedItems = new List<Dictionary<string, object>>();
+
+            _logger.LogInformation("Checking {Count} items for Spotify playlists", itemsArray.Count);
+
+            foreach (var item in itemsArray)
+            {
+                var itemDict = JsonSerializer.Deserialize<Dictionary<string, object>>(item.GetRawText());
+                if (itemDict == null)
+                {
+                    continue;
+                }
+
+                // Check if this is a Spotify playlist
+                if (item.TryGetProperty("Id", out var idProp))
+                {
+                    var playlistId = idProp.GetString();
+                    _logger.LogDebug("Checking item with ID: {Id}", playlistId);
+                    
+                    if (!string.IsNullOrEmpty(playlistId) && _spotifySettings.IsSpotifyPlaylist(playlistId))
+                    {
+                        _logger.LogInformation("Found Spotify playlist: {Id}", playlistId);
+                        
+                        // This is a Spotify playlist - get the actual track count
+                        var playlistConfig = _spotifySettings.GetPlaylistById(playlistId);
+                        
+                        if (playlistConfig != null)
+                        {
+                            var playlistName = playlistConfig.Name;
+                            var missingTracksKey = $"spotify:missing:{playlistName}";
+                            var missingTracks = await _cache.GetAsync<List<allstarr.Models.Spotify.MissingTrack>>(missingTracksKey);
+                            
+                            _logger.LogInformation("Cache lookup for {Key}: {Count} tracks", 
+                                missingTracksKey, missingTracks?.Count ?? 0);
+                            
+                            // Fallback to file cache
+                            if (missingTracks == null || missingTracks.Count == 0)
+                            {
+                                _logger.LogInformation("Trying file cache for {Name}", playlistName);
+                                missingTracks = await LoadMissingTracksFromFile(playlistName);
+                                _logger.LogInformation("File cache result: {Count} tracks", missingTracks?.Count ?? 0);
+                            }
+                            
+                            // Get local tracks count from Jellyfin
+                            var localTracksCount = 0;
+                            try
+                            {
+                                var (localTracksResponse, _) = await _proxyService.GetJsonAsync(
+                                    $"Playlists/{playlistId}/Items", 
+                                    null, 
+                                    Request.Headers);
+                                
+                                if (localTracksResponse != null && 
+                                    localTracksResponse.RootElement.TryGetProperty("Items", out var localItems))
+                                {
+                                    localTracksCount = localItems.GetArrayLength();
+                                    _logger.LogInformation("Found {Count} local tracks in Jellyfin playlist {Name}", 
+                                        localTracksCount, playlistName);
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                _logger.LogWarning(ex, "Failed to get local tracks count for {Name}", playlistName);
+                            }
+                            
+                            if (missingTracks != null && missingTracks.Count > 0)
+                            {
+                                // Update ChildCount to show total tracks (local + external)
+                                var totalCount = localTracksCount + missingTracks.Count;
+                                itemDict["ChildCount"] = totalCount;
+                                modified = true;
+                                _logger.LogInformation("✓ Updated ChildCount for Spotify playlist {Name} to {Total} ({Local} local + {External} external)", 
+                                    playlistName, totalCount, localTracksCount, missingTracks.Count);
+                            }
+                            else if (localTracksCount > 0)
+                            {
+                                // No external tracks, but we have local tracks
+                                itemDict["ChildCount"] = localTracksCount;
+                                modified = true;
+                                _logger.LogInformation("✓ Updated ChildCount for Spotify playlist {Name} to {Count} (local only, no external tracks)", 
+                                    playlistName, localTracksCount);
+                            }
+                            else
+                            {
+                                _logger.LogWarning("No tracks found for {Name} (neither local nor external)", playlistName);
+                            }
+                        }
+                    }
+                }
+
+                updatedItems.Add(itemDict);
+            }
+
+            if (!modified)
+            {
+                _logger.LogInformation("No Spotify playlists found to update");
+                return response;
+            }
+
+            _logger.LogInformation("Modified {Count} Spotify playlists, rebuilding response", 
+                updatedItems.Count(i => i.ContainsKey("ChildCount")));
+
+            // Rebuild the response with updated items
+            var responseDict = JsonSerializer.Deserialize<Dictionary<string, object>>(response.RootElement.GetRawText());
+            if (responseDict != null)
+            {
+                responseDict["Items"] = updatedItems;
+                var updatedJson = JsonSerializer.Serialize(responseDict);
+                return JsonDocument.Parse(updatedJson);
+            }
+
+            return response;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to update Spotify playlist counts");
+            return response;
+        }
+    }
+
+    /// <summary>
+    /// Logs endpoint usage to a file for analysis.
+    /// Creates a CSV file with timestamp, method, path, and query string.
+    /// </summary>
+    private async Task LogEndpointUsageAsync(string path, string method)
+    {
+        try
+        {
+            var logDir = "/app/cache/endpoint-usage";
+            Directory.CreateDirectory(logDir);
+            
+            var logFile = Path.Combine(logDir, "endpoints.csv");
+            var timestamp = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss");
+            var queryString = Request.QueryString.HasValue ? Request.QueryString.Value : "";
+            
+            // Sanitize path and query for CSV (remove commas, quotes, newlines)
+            var sanitizedPath = path.Replace(",", ";").Replace("\"", "'").Replace("\n", " ").Replace("\r", " ");
+            var sanitizedQuery = queryString.Replace(",", ";").Replace("\"", "'").Replace("\n", " ").Replace("\r", " ");
+            
+            var logLine = $"{timestamp},{method},{sanitizedPath},{sanitizedQuery}\n";
+            
+            // Append to file (thread-safe)
+            await System.IO.File.AppendAllTextAsync(logFile, logLine);
+        }
+        catch (Exception ex)
+        {
+            // Don't let logging failures break the request
+            _logger.LogDebug(ex, "Failed to log endpoint usage");
+        }
+    }
+
     private static string[]? ParseItemTypes(string? includeItemTypes)
     {
         if (string.IsNullOrWhiteSpace(includeItemTypes))
@@ -1761,28 +2666,52 @@ public class JellyfinController : ControllerBase
     private static List<(T Item, int Score)> ScoreSearchResults<T>(
         string query,
         List<T> items,
-        Func<T, string> primaryField,
-        Func<T, string?> secondaryField,
+        Func<T, string> titleField,
+        Func<T, string?> artistField,
+        Func<T, string?> albumField,
         bool isExternal = false)
     {
         return items.Select(item =>
         {
-            var primary = primaryField(item) ?? "";
-            var secondary = secondaryField(item) ?? "";
+            var title = titleField(item) ?? "";
+            var artist = artistField(item) ?? "";
+            var album = albumField(item) ?? "";
 
-            // Score against primary field (title/name)
-            var primaryScore = FuzzyMatcher.CalculateSimilarity(query, primary);
+            // Token-based fuzzy matching: split query and fields into words
+            var queryTokens = query.ToLower()
+                .Split(new[] { ' ', '-', '_' }, StringSplitOptions.RemoveEmptyEntries)
+                .ToList();
 
-            // Score against secondary field (artist) if provided
-            var secondaryScore = string.IsNullOrEmpty(secondary) 
-                ? 0 
-                : FuzzyMatcher.CalculateSimilarity(query, secondary);
+            var fieldText = $"{title} {artist} {album}".ToLower();
+            var fieldTokens = fieldText
+                .Split(new[] { ' ', '-', '_' }, StringSplitOptions.RemoveEmptyEntries)
+                .ToList();
 
-            // Use the better of the two scores
-            var baseScore = Math.Max(primaryScore, secondaryScore);
+            if (queryTokens.Count == 0) return (item, 0);
+
+            // Count how many query tokens match field tokens (with fuzzy tolerance)
+            var matchedTokens = 0;
+            foreach (var queryToken in queryTokens)
+            {
+                // Check if any field token matches this query token
+                var hasMatch = fieldTokens.Any(fieldToken =>
+                {
+                    // Exact match or substring match
+                    if (fieldToken.Contains(queryToken) || queryToken.Contains(fieldToken))
+                        return true;
+
+                    // Fuzzy match with Levenshtein distance
+                    var similarity = FuzzyMatcher.CalculateSimilarity(queryToken, fieldToken);
+                    return similarity >= 70; // 70% similarity threshold for individual words
+                });
+
+                if (hasMatch) matchedTokens++;
+            }
+
+            // Score = percentage of query tokens that matched
+            var baseScore = (matchedTokens * 100) / queryTokens.Count;
 
             // Give external results a small boost (+5 points) to prioritize the larger catalog
-            // This means external results will rank slightly higher when scores are close
             var finalScore = isExternal ? Math.Min(100, baseScore + 5) : baseScore;
 
             return (item, finalScore);
@@ -1790,5 +2719,649 @@ public class JellyfinController : ControllerBase
     }
 
     #endregion
+
+    #region Spotify Playlist Injection
+
+    /// <summary>
+    /// Gets tracks for a Spotify playlist by matching missing tracks against external providers
+    /// and merging with existing local tracks from Jellyfin.
+    /// </summary>
+    private async Task<IActionResult> GetSpotifyPlaylistTracksAsync(string spotifyPlaylistName, string playlistId)
+    {
+        try
+        {
+            var cacheKey = $"spotify:matched:{spotifyPlaylistName}";
+            var cachedTracks = await _cache.GetAsync<List<Song>>(cacheKey);
+            
+            if (cachedTracks != null)
+            {
+                _logger.LogDebug("Returning {Count} cached matched tracks for {Playlist}", 
+                    cachedTracks.Count, spotifyPlaylistName);
+                return _responseBuilder.CreateItemsResponse(cachedTracks);
+            }
+
+            // Get existing Jellyfin playlist items (tracks the plugin already found)
+            var (existingTracksResponse, _) = await _proxyService.GetJsonAsync(
+                $"Playlists/{playlistId}/Items", 
+                null, 
+                Request.Headers);
+            
+            var existingTracks = new List<Song>();
+            var existingSpotifyIds = new HashSet<string>();
+            
+            if (existingTracksResponse != null && 
+                existingTracksResponse.RootElement.TryGetProperty("Items", out var items))
+            {
+                foreach (var item in items.EnumerateArray())
+                {
+                    var song = _modelMapper.ParseSong(item);
+                    existingTracks.Add(song);
+                    
+                    // Track Spotify IDs to avoid duplicates
+                    if (item.TryGetProperty("ProviderIds", out var providerIds) &&
+                        providerIds.TryGetProperty("Spotify", out var spotifyId))
+                    {
+                        existingSpotifyIds.Add(spotifyId.GetString() ?? "");
+                    }
+                }
+                _logger.LogInformation("Found {Count} existing tracks in Jellyfin playlist", existingTracks.Count);
+            }
+
+            var missingTracksKey = $"spotify:missing:{spotifyPlaylistName}";
+            var missingTracks = await _cache.GetAsync<List<allstarr.Models.Spotify.MissingTrack>>(missingTracksKey);
+            
+            // Fallback to file cache if Redis is empty
+            if (missingTracks == null || missingTracks.Count == 0)
+            {
+                missingTracks = await LoadMissingTracksFromFile(spotifyPlaylistName);
+                
+                // If we loaded from file, restore to Redis with no expiration
+                if (missingTracks != null && missingTracks.Count > 0)
+                {
+                    await _cache.SetAsync(missingTracksKey, missingTracks, TimeSpan.FromDays(365));
+                    _logger.LogInformation("Restored {Count} missing tracks from file cache for {Playlist} (no expiration)", 
+                        missingTracks.Count, spotifyPlaylistName);
+                }
+            }
+            
+            if (missingTracks == null || missingTracks.Count == 0)
+            {
+                _logger.LogInformation("No missing tracks found for {Playlist}, returning {Count} existing tracks", 
+                    spotifyPlaylistName, existingTracks.Count);
+                return _responseBuilder.CreateItemsResponse(existingTracks);
+            }
+
+            _logger.LogInformation("Matching {Count} missing tracks for {Playlist}", 
+                missingTracks.Count, spotifyPlaylistName);
+
+            // Match missing tracks sequentially with rate limiting (excluding ones we already have locally)
+            var matchedBySpotifyId = new Dictionary<string, Song>();
+            var tracksToMatch = missingTracks
+                .Where(track => !existingSpotifyIds.Contains(track.SpotifyId))
+                .ToList();
+
+            foreach (var track in tracksToMatch)
+            {
+                try
+                {
+                    // Search with just title and artist for better matching
+                    var query = $"{track.Title} {track.PrimaryArtist}";
+                    var results = await _metadataService.SearchSongsAsync(query, limit: 5);
+                    
+                    if (results.Count > 0)
+                    {
+                        // Fuzzy match to find best result
+                        // Check that ALL artists match (not just some)
+                        var bestMatch = results
+                            .Select(song => new
+                            {
+                                Song = song,
+                                TitleScore = FuzzyMatcher.CalculateSimilarity(track.Title, song.Title),
+                                // Calculate artist score by checking ALL artists match
+                                ArtistScore = CalculateArtistMatchScore(track.Artists, song.Artist, song.Contributors)
+                            })
+                            .Select(x => new
+                            {
+                                x.Song,
+                                x.TitleScore,
+                                x.ArtistScore,
+                                TotalScore = (x.TitleScore * 0.6) + (x.ArtistScore * 0.4) // Weight title more
+                            })
+                            .OrderByDescending(x => x.TotalScore)
+                            .FirstOrDefault();
+                        
+                        // Only add if match is good enough (>60% combined score)
+                        if (bestMatch != null && bestMatch.TotalScore >= 60)
+                        {
+                            _logger.LogDebug("Matched '{Title}' by {Artist} -> '{MatchTitle}' by {MatchArtist} (score: {Score:F1})",
+                                track.Title, track.PrimaryArtist, 
+                                bestMatch.Song.Title, bestMatch.Song.Artist, 
+                                bestMatch.TotalScore);
+                            matchedBySpotifyId[track.SpotifyId] = bestMatch.Song;
+                        }
+                        else
+                        {
+                            _logger.LogDebug("No good match for '{Title}' by {Artist} (best score: {Score:F1})",
+                                track.Title, track.PrimaryArtist, bestMatch?.TotalScore ?? 0);
+                        }
+                    }
+                    
+                    // Rate limiting: small delay between searches to avoid overwhelming the service
+                    await Task.Delay(100); // 100ms delay = max 10 searches/second
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogDebug(ex, "Failed to match track: {Title} - {Artist}", 
+                        track.Title, track.PrimaryArtist);
+                }
+            }
+
+            // Build final track list based on playlist configuration
+            // Local tracks position is configurable per-playlist
+            var playlistConfig = _spotifySettings.GetPlaylistById(playlistId);
+            var localTracksPosition = playlistConfig?.LocalTracksPosition ?? LocalTracksPosition.First;
+            
+            var finalTracks = new List<Song>();
+            if (localTracksPosition == LocalTracksPosition.First)
+            {
+                // Local tracks first, external tracks at the end
+                finalTracks.AddRange(existingTracks);
+                finalTracks.AddRange(matchedBySpotifyId.Values);
+            }
+            else
+            {
+                // External tracks first, local tracks at the end
+                finalTracks.AddRange(matchedBySpotifyId.Values);
+                finalTracks.AddRange(existingTracks);
+            }
+
+            await _cache.SetAsync(cacheKey, finalTracks, TimeSpan.FromHours(1));
+
+            _logger.LogInformation("Final playlist: {Total} tracks ({Existing} local + {Matched} external, LocalTracksPosition: {Position})", 
+                finalTracks.Count,
+                existingTracks.Count,
+                matchedBySpotifyId.Count,
+                localTracksPosition);
+
+            return _responseBuilder.CreateItemsResponse(finalTracks);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error getting Spotify playlist tracks {PlaylistName}", spotifyPlaylistName);
+            return _responseBuilder.CreateError(500, "Failed to get Spotify playlist tracks");
+        }
+    }
+
+    /// <summary>
+    /// Copies an external track to the kept folder when favorited.
+    /// </summary>
+    private async Task CopyExternalTrackToKeptAsync(string itemId, string provider, string externalId)
+    {
+        try
+        {
+            // Get the song metadata
+            var song = await _metadataService.GetSongAsync(provider, externalId);
+            if (song == null)
+            {
+                _logger.LogWarning("Could not find song metadata for {ItemId}", itemId);
+                return;
+            }
+
+            // Trigger download first
+            _logger.LogInformation("Downloading track for kept folder: {ItemId}", itemId);
+            string downloadPath;
+            
+            try
+            {
+                downloadPath = await _downloadService.DownloadSongAsync(provider, externalId);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to download track {ItemId}", itemId);
+                return;
+            }
+
+            // Create kept folder structure: /app/kept/Artist/Album/
+            var keptBasePath = "/app/kept";
+            var keptArtistPath = Path.Combine(keptBasePath, PathHelper.SanitizeFileName(song.Artist));
+            var keptAlbumPath = Path.Combine(keptArtistPath, PathHelper.SanitizeFileName(song.Album));
+            
+            Directory.CreateDirectory(keptAlbumPath);
+
+            // Copy file to kept folder
+            var fileName = Path.GetFileName(downloadPath);
+            var keptFilePath = Path.Combine(keptAlbumPath, fileName);
+
+            if (System.IO.File.Exists(keptFilePath))
+            {
+                _logger.LogInformation("Track already exists in kept folder: {Path}", keptFilePath);
+                return;
+            }
+
+            System.IO.File.Copy(downloadPath, keptFilePath, overwrite: false);
+            _logger.LogInformation("✓ Copied favorited track to kept folder: {Path}", keptFilePath);
+            
+            // Also copy cover art if it exists
+            var coverPath = Path.Combine(Path.GetDirectoryName(downloadPath)!, "cover.jpg");
+            if (System.IO.File.Exists(coverPath))
+            {
+                var keptCoverPath = Path.Combine(keptAlbumPath, "cover.jpg");
+                if (!System.IO.File.Exists(keptCoverPath))
+                {
+                    System.IO.File.Copy(coverPath, keptCoverPath, overwrite: false);
+                    _logger.LogDebug("Copied cover art to kept folder");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error copying external track {ItemId} to kept folder", itemId);
+        }
+    }
+
+    /// <summary>
+    /// Loads missing tracks from file cache as fallback when Redis is empty.
+    /// </summary>
+    private async Task<List<allstarr.Models.Spotify.MissingTrack>?> LoadMissingTracksFromFile(string playlistName)
+    {
+        try
+        {
+            var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
+            var filePath = Path.Combine("/app/cache/spotify", $"{safeName}_missing.json");
+            
+            if (!System.IO.File.Exists(filePath))
+            {
+                _logger.LogDebug("No file cache found for {Playlist} at {Path}", playlistName, filePath);
+                return null;
+            }
+            
+            // No expiration check - cache persists until next Jellyfin job generates new file
+            var fileAge = DateTime.UtcNow - System.IO.File.GetLastWriteTimeUtc(filePath);
+            _logger.LogDebug("File cache for {Playlist} age: {Age:F1}h (no expiration)", playlistName, fileAge.TotalHours);
+            
+            var json = await System.IO.File.ReadAllTextAsync(filePath);
+            var tracks = JsonSerializer.Deserialize<List<allstarr.Models.Spotify.MissingTrack>>(json);
+            
+            _logger.LogInformation("Loaded {Count} missing tracks from file cache for {Playlist} (age: {Age:F1}h)", 
+                tracks?.Count ?? 0, playlistName, fileAge.TotalHours);
+            
+            return tracks;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to load missing tracks from file for {Playlist}", playlistName);
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Manual trigger endpoint to force fetch Spotify missing tracks.
+    /// GET /spotify/sync?api_key=YOUR_KEY
+    /// </summary>
+    [HttpGet("spotify/sync", Order = 1)]
+    [ServiceFilter(typeof(ApiKeyAuthFilter))]
+    public async Task<IActionResult> TriggerSpotifySync([FromServices] IEnumerable<IHostedService> hostedServices)
+    {
+        if (!_spotifySettings.Enabled)
+        {
+            return BadRequest(new { error = "Spotify Import is not enabled" });
+        }
+
+        _logger.LogInformation("Manual Spotify sync triggered");
+        
+        // Find the SpotifyMissingTracksFetcher service
+        var fetcherService = hostedServices
+            .OfType<allstarr.Services.Spotify.SpotifyMissingTracksFetcher>()
+            .FirstOrDefault();
+        
+        if (fetcherService == null)
+        {
+            return StatusCode(500, new { error = "SpotifyMissingTracksFetcher not found" });
+        }
+        
+        // Trigger fetch manually
+        await fetcherService.TriggerFetchAsync();
+        
+        // Check what was cached
+        var results = new Dictionary<string, object>();
+        foreach (var playlist in _spotifySettings.Playlists)
+        {
+            var cacheKey = $"spotify:missing:{playlist.Name}";
+            var tracks = await _cache.GetAsync<List<allstarr.Models.Spotify.MissingTrack>>(cacheKey);
+            
+            if (tracks != null && tracks.Count > 0)
+            {
+                results[playlist.Name] = new { 
+                    status = "success", 
+                    tracks = tracks.Count,
+                    localTracksPosition = playlist.LocalTracksPosition.ToString()
+                };
+            }
+            else
+            {
+                results[playlist.Name] = new { 
+                    status = "not_found", 
+                    message = "No missing tracks found" 
+                };
+            }
+        }
+        
+        return Ok(results);
+    }
+    
+    /// <summary>
+    /// Manually trigger track matching for all Spotify playlists.
+    /// GET /spotify/match?api_key=YOUR_KEY
+    /// </summary>
+    [HttpGet("spotify/match", Order = 1)]
+    [ServiceFilter(typeof(ApiKeyAuthFilter))]
+    public async Task<IActionResult> TriggerSpotifyMatch([FromServices] IEnumerable<IHostedService> hostedServices)
+    {
+        if (!_spotifySettings.Enabled)
+        {
+            return BadRequest(new { error = "Spotify Import is not enabled" });
+        }
+
+        _logger.LogInformation("Manual Spotify track matching triggered");
+        
+        // Find the SpotifyTrackMatchingService
+        var matchingService = hostedServices
+            .OfType<allstarr.Services.Spotify.SpotifyTrackMatchingService>()
+            .FirstOrDefault();
+        
+        if (matchingService == null)
+        {
+            return StatusCode(500, new { error = "SpotifyTrackMatchingService not found" });
+        }
+        
+        // Trigger matching asynchronously
+        _ = Task.Run(async () =>
+        {
+            try
+            {
+                await matchingService.TriggerMatchingAsync();
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error during manual track matching");
+            }
+        });
+        
+        return Ok(new 
+        { 
+            status = "started",
+            message = "Track matching started in background. Check logs for progress.",
+            playlists = _spotifySettings.Playlists.Select(p => new { p.Name, p.Id, localTracksPosition = p.LocalTracksPosition.ToString() })
+        });
+    }
+    
+    private List<allstarr.Models.Spotify.MissingTrack> ParseMissingTracksJson(string json)
+    {
+        var tracks = new List<allstarr.Models.Spotify.MissingTrack>();
+        
+        try
+        {
+            var doc = JsonDocument.Parse(json);
+            
+            foreach (var item in doc.RootElement.EnumerateArray())
+            {
+                var track = new allstarr.Models.Spotify.MissingTrack
+                {
+                    SpotifyId = item.GetProperty("Id").GetString() ?? "",
+                    Title = item.GetProperty("Name").GetString() ?? "",
+                    Album = item.GetProperty("AlbumName").GetString() ?? "",
+                    Artists = item.GetProperty("ArtistNames")
+                        .EnumerateArray()
+                        .Select(a => a.GetString() ?? "")
+                        .Where(a => !string.IsNullOrEmpty(a))
+                        .ToList()
+                };
+                
+                if (!string.IsNullOrEmpty(track.Title))
+                {
+                    tracks.Add(track);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to parse missing tracks JSON");
+        }
+        
+        return tracks;
+    }
+
+    #endregion
+    
+    #region Spotify Debug
+    
+    /// <summary>
+    /// Clear Spotify playlist cache to force re-matching.
+    /// GET /spotify/clear-cache?api_key=YOUR_KEY
+    /// </summary>
+    [HttpGet("spotify/clear-cache")]
+    [ServiceFilter(typeof(ApiKeyAuthFilter))]
+    public async Task<IActionResult> ClearSpotifyCache()
+    {
+        if (!_spotifySettings.Enabled)
+        {
+            return BadRequest(new { error = "Spotify Import is not enabled" });
+        }
+
+        var cleared = new List<string>();
+        
+        foreach (var playlist in _spotifySettings.Playlists)
+        {
+            var matchedKey = $"spotify:matched:{playlist.Name}";
+            await _cache.DeleteAsync(matchedKey);
+            cleared.Add(playlist.Name);
+            _logger.LogInformation("Cleared cache for {Playlist}", playlist.Name);
+        }
+        
+        return Ok(new { status = "success", cleared = cleared });
+    }
+    
+    #endregion
+    
+    #region Debug & Monitoring
+    
+    /// <summary>
+    /// Gets endpoint usage statistics from the log file.
+    /// GET /debug/endpoint-usage?api_key=YOUR_KEY
+    /// Optional query params: top=50 (default 100), since=2024-01-01
+    /// </summary>
+    [HttpGet("debug/endpoint-usage")]
+    [ServiceFilter(typeof(ApiKeyAuthFilter))]
+    public async Task<IActionResult> GetEndpointUsage(
+        [FromQuery] int top = 100,
+        [FromQuery] string? since = null)
+    {
+        try
+        {
+            var logFile = "/app/cache/endpoint-usage/endpoints.csv";
+            
+            if (!System.IO.File.Exists(logFile))
+            {
+                return Ok(new 
+                { 
+                    message = "No endpoint usage data collected yet",
+                    endpoints = Array.Empty<object>()
+                });
+            }
+            
+            var lines = await System.IO.File.ReadAllLinesAsync(logFile);
+            
+            // Parse CSV and filter by date if provided
+            DateTime? sinceDate = null;
+            if (!string.IsNullOrEmpty(since) && DateTime.TryParse(since, out var parsedDate))
+            {
+                sinceDate = parsedDate;
+            }
+            
+            var entries = lines
+                .Select(line => line.Split(','))
+                .Where(parts => parts.Length >= 3)
+                .Where(parts => !sinceDate.HasValue || 
+                    (DateTime.TryParse(parts[0], out var entryDate) && entryDate >= sinceDate.Value))
+                .Select(parts => new
+                {
+                    Timestamp = parts[0],
+                    Method = parts.Length > 1 ? parts[1] : "",
+                    Path = parts.Length > 2 ? parts[2] : "",
+                    Query = parts.Length > 3 ? parts[3] : ""
+                })
+                .ToList();
+            
+            // Group by path and count
+            var pathCounts = entries
+                .GroupBy(e => new { e.Method, e.Path })
+                .Select(g => new
+                {
+                    Method = g.Key.Method,
+                    Path = g.Key.Path,
+                    Count = g.Count(),
+                    FirstSeen = g.Min(e => e.Timestamp),
+                    LastSeen = g.Max(e => e.Timestamp)
+                })
+                .OrderByDescending(x => x.Count)
+                .Take(top)
+                .ToList();
+            
+            return Ok(new
+            {
+                totalRequests = entries.Count,
+                uniqueEndpoints = pathCounts.Count,
+                topEndpoints = pathCounts,
+                logFile = logFile,
+                logSize = new FileInfo(logFile).Length
+            });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to get endpoint usage");
+            return StatusCode(500, new { error = ex.Message });
+        }
+    }
+
+    /// <summary>
+    /// Clears the endpoint usage log file.
+    /// DELETE /debug/endpoint-usage?api_key=YOUR_KEY
+    /// </summary>
+    [HttpDelete("debug/endpoint-usage")]
+    [ServiceFilter(typeof(ApiKeyAuthFilter))]
+    public IActionResult ClearEndpointUsage()
+    {
+        try
+        {
+            var logFile = "/app/cache/endpoint-usage/endpoints.csv";
+            
+            if (System.IO.File.Exists(logFile))
+            {
+                System.IO.File.Delete(logFile);
+                return Ok(new { status = "success", message = "Endpoint usage log cleared" });
+            }
+            
+            return Ok(new { status = "success", message = "No log file to clear" });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to clear endpoint usage log");
+            return StatusCode(500, new { error = ex.Message });
+        }
+    }
+    
+    #endregion
+    
+    /// <summary>
+    /// Calculates artist match score ensuring ALL artists are present.
+    /// Penalizes if artist counts don't match or if any artist is missing.
+    /// </summary>
+    private static double CalculateArtistMatchScore(List<string> spotifyArtists, string songMainArtist, List<string> songContributors)
+    {
+        if (spotifyArtists.Count == 0 || string.IsNullOrEmpty(songMainArtist))
+            return 0;
+        
+        // Build list of all song artists (main + contributors)
+        var allSongArtists = new List<string> { songMainArtist };
+        allSongArtists.AddRange(songContributors);
+        
+        // If artist counts differ significantly, penalize
+        var countDiff = Math.Abs(spotifyArtists.Count - allSongArtists.Count);
+        if (countDiff > 1) // Allow 1 artist difference (sometimes features are listed differently)
+            return 0;
+        
+        // Check that each Spotify artist has a good match in song artists
+        var spotifyScores = new List<double>();
+        foreach (var spotifyArtist in spotifyArtists)
+        {
+            var bestMatch = allSongArtists.Max(songArtist => 
+                FuzzyMatcher.CalculateSimilarity(spotifyArtist, songArtist));
+            spotifyScores.Add(bestMatch);
+        }
+        
+        // Check that each song artist has a good match in Spotify artists
+        var songScores = new List<double>();
+        foreach (var songArtist in allSongArtists)
+        {
+            var bestMatch = spotifyArtists.Max(spotifyArtist => 
+                FuzzyMatcher.CalculateSimilarity(songArtist, spotifyArtist));
+            songScores.Add(bestMatch);
+        }
+        
+        // Average all scores - this ensures ALL artists must match well
+        var allScores = spotifyScores.Concat(songScores);
+        var avgScore = allScores.Average();
+        
+        // Penalize if any individual artist match is poor (< 70)
+        var minScore = allScores.Min();
+        if (minScore < 70)
+            avgScore *= 0.7; // 30% penalty for poor individual match
+        
+        return avgScore;
+    }
+
+    /// <summary>
+    /// Extracts device information from Authorization header.
+    /// </summary>
+    private (string? deviceId, string? client, string? device, string? version) ExtractDeviceInfo(IHeaderDictionary headers)
+    {
+        string? deviceId = null;
+        string? client = null;
+        string? device = null;
+        string? version = null;
+        
+        // Check X-Emby-Authorization FIRST (most Jellyfin clients use this)
+        // Then fall back to Authorization header
+        string? authStr = null;
+        if (headers.TryGetValue("X-Emby-Authorization", out var embyAuthHeader))
+        {
+            authStr = embyAuthHeader.ToString();
+        }
+        else if (headers.TryGetValue("Authorization", out var authHeader))
+        {
+            authStr = authHeader.ToString();
+        }
+        
+        if (!string.IsNullOrEmpty(authStr))
+        {
+            // Parse: MediaBrowser Client="...", Device="...", DeviceId="...", Version="..."
+            var parts = authStr.Replace("MediaBrowser ", "").Split(',');
+            foreach (var part in parts)
+            {
+                var kv = part.Trim().Split('=');
+                if (kv.Length == 2)
+                {
+                    var key = kv[0].Trim();
+                    var value = kv[1].Trim('"');
+                    if (key == "DeviceId") deviceId = value;
+                    else if (key == "Client") client = value;
+                    else if (key == "Device") device = value;
+                    else if (key == "Version") version = value;
+                }
+            }
+        }
+        
+        return (deviceId, client, device, version);
+    }
 }
 // force rebuild Sun Jan 25 13:22:47 EST 2026

allstarr/Filters/ApiKeyAuthFilter.cs

@@ -0,0 +1,52 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.Extensions.Options;
+using allstarr.Models.Settings;
+
+namespace allstarr.Filters;
+
+/// <summary>
+/// Simple API key authentication filter for admin endpoints.
+/// Validates against Jellyfin API key via query parameter or header.
+/// </summary>
+public class ApiKeyAuthFilter : IAsyncActionFilter
+{
+    private readonly JellyfinSettings _settings;
+    private readonly ILogger<ApiKeyAuthFilter> _logger;
+
+    public ApiKeyAuthFilter(
+        IOptions<JellyfinSettings> settings,
+        ILogger<ApiKeyAuthFilter> logger)
+    {
+        _settings = settings.Value;
+        _logger = logger;
+    }
+
+    public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+    {
+        var request = context.HttpContext.Request;
+        
+        // Extract API key from query parameter or header
+        var apiKey = request.Query["api_key"].FirstOrDefault()
+                  ?? request.Headers["X-Api-Key"].FirstOrDefault()
+                  ?? request.Headers["X-Emby-Token"].FirstOrDefault();
+
+        // Validate API key
+        if (string.IsNullOrEmpty(apiKey) || !string.Equals(apiKey, _settings.ApiKey, StringComparison.Ordinal))
+        {
+            _logger.LogWarning("Unauthorized access attempt to {Path} from {IP}", 
+                request.Path, 
+                context.HttpContext.Connection.RemoteIpAddress);
+            
+            context.Result = new UnauthorizedObjectResult(new
+            {
+                error = "Unauthorized",
+                message = "Valid API key required. Provide via ?api_key=YOUR_KEY or X-Api-Key header."
+            });
+            return;
+        }
+
+        _logger.LogDebug("API key authentication successful for {Path}", request.Path);
+        await next();
+    }
+}

allstarr/Middleware/WebSocketProxyMiddleware.cs

@@ -0,0 +1,240 @@
+using System.Net.WebSockets;
+using Microsoft.Extensions.Options;
+using allstarr.Models.Settings;
+
+namespace allstarr.Middleware;
+
+/// <summary>
+/// Middleware that proxies WebSocket connections to Jellyfin server.
+/// This enables real-time features like session tracking, remote control, and live updates.
+/// </summary>
+public class WebSocketProxyMiddleware
+{
+    private readonly RequestDelegate _next;
+    private readonly JellyfinSettings _settings;
+    private readonly ILogger<WebSocketProxyMiddleware> _logger;
+
+    public WebSocketProxyMiddleware(
+        RequestDelegate next,
+        IOptions<JellyfinSettings> settings,
+        ILogger<WebSocketProxyMiddleware> logger)
+    {
+        _next = next;
+        _settings = settings.Value;
+        _logger = logger;
+        
+        _logger.LogWarning("🔧 WEBSOCKET: WebSocketProxyMiddleware initialized - Jellyfin URL: {Url}", _settings.Url);
+    }
+
+    public async Task InvokeAsync(HttpContext context)
+    {
+        // Log ALL requests for debugging
+        var path = context.Request.Path.Value ?? "";
+        var isWebSocket = context.WebSockets.IsWebSocketRequest;
+        
+        // Log any request that might be WebSocket-related
+        if (path.Contains("socket", StringComparison.OrdinalIgnoreCase) || 
+            path.Contains("ws", StringComparison.OrdinalIgnoreCase) ||
+            isWebSocket ||
+            context.Request.Headers.ContainsKey("Upgrade"))
+        {
+            _logger.LogWarning("🔍 WEBSOCKET: Potential WebSocket request: Path={Path}, IsWs={IsWs}, Method={Method}, Upgrade={Upgrade}, Connection={Connection}",
+                path,
+                isWebSocket,
+                context.Request.Method,
+                context.Request.Headers["Upgrade"].ToString(),
+                context.Request.Headers["Connection"].ToString());
+        }
+
+        // Check if this is a WebSocket request to /socket
+        if (context.Request.Path.StartsWithSegments("/socket", StringComparison.OrdinalIgnoreCase) &&
+            context.WebSockets.IsWebSocketRequest)
+        {
+            _logger.LogWarning("🔌 WEBSOCKET: WebSocket connection request received from {RemoteIp}", 
+                context.Connection.RemoteIpAddress);
+
+            await HandleWebSocketProxyAsync(context);
+            return;
+        }
+
+        // Not a WebSocket request, pass to next middleware
+        await _next(context);
+    }
+
+    private async Task HandleWebSocketProxyAsync(HttpContext context)
+    {
+        ClientWebSocket? serverWebSocket = null;
+        WebSocket? clientWebSocket = null;
+
+        try
+        {
+            // Accept the WebSocket connection from the client
+            clientWebSocket = await context.WebSockets.AcceptWebSocketAsync();
+            _logger.LogWarning("✓ WEBSOCKET: Client WebSocket accepted");
+
+            // Build Jellyfin WebSocket URL
+            var jellyfinUrl = _settings.Url?.TrimEnd('/') ?? "";
+            var wsScheme = jellyfinUrl.StartsWith("https://", StringComparison.OrdinalIgnoreCase) ? "wss://" : "ws://";
+            var jellyfinHost = jellyfinUrl.Replace("https://", "").Replace("http://", "");
+            var jellyfinWsUrl = $"{wsScheme}{jellyfinHost}/socket";
+
+            // Add query parameters if present (e.g., ?api_key=xxx or ?deviceId=xxx)
+            if (context.Request.QueryString.HasValue)
+            {
+                jellyfinWsUrl += context.Request.QueryString.Value;
+            }
+
+            _logger.LogWarning("🔗 WEBSOCKET: Connecting to Jellyfin WebSocket: {Url}", jellyfinWsUrl);
+
+            // Connect to Jellyfin WebSocket
+            serverWebSocket = new ClientWebSocket();
+
+            // Forward authentication headers - check X-Emby-Authorization FIRST
+            // Most Jellyfin clients use X-Emby-Authorization, not Authorization
+            if (context.Request.Headers.TryGetValue("X-Emby-Authorization", out var embyAuthHeader))
+            {
+                serverWebSocket.Options.SetRequestHeader("X-Emby-Authorization", embyAuthHeader.ToString());
+                _logger.LogWarning("🔑 WEBSOCKET: Forwarded X-Emby-Authorization header");
+            }
+            else if (context.Request.Headers.TryGetValue("Authorization", out var authHeader))
+            {
+                var authValue = authHeader.ToString();
+                // If it's a MediaBrowser auth header, use X-Emby-Authorization
+                if (authValue.Contains("MediaBrowser", StringComparison.OrdinalIgnoreCase))
+                {
+                    serverWebSocket.Options.SetRequestHeader("X-Emby-Authorization", authValue);
+                    _logger.LogWarning("🔑 WEBSOCKET: Converted Authorization to X-Emby-Authorization header");
+                }
+                else
+                {
+                    serverWebSocket.Options.SetRequestHeader("Authorization", authValue);
+                    _logger.LogWarning("🔑 WEBSOCKET: Forwarded Authorization header");
+                }
+            }
+
+            // Set user agent
+            serverWebSocket.Options.SetRequestHeader("User-Agent", "Allstarr/1.0");
+
+            await serverWebSocket.ConnectAsync(new Uri(jellyfinWsUrl), context.RequestAborted);
+            _logger.LogWarning("✓ WEBSOCKET: Connected to Jellyfin WebSocket");
+
+            // Start bidirectional proxying
+            var clientToServer = ProxyMessagesAsync(clientWebSocket, serverWebSocket, "Client→Server", context.RequestAborted);
+            var serverToClient = ProxyMessagesAsync(serverWebSocket, clientWebSocket, "Server→Client", context.RequestAborted);
+
+            // Wait for either direction to complete
+            await Task.WhenAny(clientToServer, serverToClient);
+
+            _logger.LogWarning("🔌 WEBSOCKET: WebSocket proxy connection closed");
+        }
+        catch (WebSocketException wsEx)
+        {
+            _logger.LogWarning(wsEx, "⚠️ WEBSOCKET: WebSocket error: {Message}", wsEx.Message);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "❌ WEBSOCKET: Error in WebSocket proxy");
+        }
+        finally
+        {
+            // Clean up connections
+            if (clientWebSocket?.State == WebSocketState.Open)
+            {
+                try
+                {
+                    await clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Proxy closing", CancellationToken.None);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogDebug(ex, "Error closing client WebSocket");
+                }
+            }
+
+            if (serverWebSocket?.State == WebSocketState.Open)
+            {
+                try
+                {
+                    await serverWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Proxy closing", CancellationToken.None);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogDebug(ex, "Error closing server WebSocket");
+                }
+            }
+
+            clientWebSocket?.Dispose();
+            serverWebSocket?.Dispose();
+
+            _logger.LogWarning("🧹 WEBSOCKET: WebSocket connections cleaned up");
+        }
+    }
+
+    private async Task ProxyMessagesAsync(
+        WebSocket source,
+        WebSocket destination,
+        string direction,
+        CancellationToken cancellationToken)
+    {
+        var buffer = new byte[1024 * 4]; // 4KB buffer
+        var messageBuffer = new List<byte>();
+
+        try
+        {
+            while (source.State == WebSocketState.Open && destination.State == WebSocketState.Open)
+            {
+                var result = await source.ReceiveAsync(new ArraySegment<byte>(buffer), cancellationToken);
+
+                if (result.MessageType == WebSocketMessageType.Close)
+                {
+                    _logger.LogWarning("🔌 WEBSOCKET {Direction}: Close message received", direction);
+                    await destination.CloseAsync(
+                        result.CloseStatus ?? WebSocketCloseStatus.NormalClosure,
+                        result.CloseStatusDescription,
+                        cancellationToken);
+                    break;
+                }
+
+                // Accumulate message fragments
+                messageBuffer.AddRange(buffer.Take(result.Count));
+
+                // If this is the end of the message, forward it
+                if (result.EndOfMessage)
+                {
+                    var messageBytes = messageBuffer.ToArray();
+                    
+                    // Log message for debugging (only in debug mode to avoid spam)
+                    if (_logger.IsEnabled(LogLevel.Debug))
+                    {
+                        var messageText = System.Text.Encoding.UTF8.GetString(messageBytes);
+                        _logger.LogDebug("{Direction}: {MessageType} message ({Size} bytes): {Preview}",
+                            direction,
+                            result.MessageType,
+                            messageBytes.Length,
+                            messageText.Length > 200 ? messageText[..200] + "..." : messageText);
+                    }
+
+                    // Forward the complete message
+                    await destination.SendAsync(
+                        new ArraySegment<byte>(messageBytes),
+                        result.MessageType,
+                        true,
+                        cancellationToken);
+
+                    messageBuffer.Clear();
+                }
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            _logger.LogWarning("⚠️ WEBSOCKET {Direction}: Operation cancelled", direction);
+        }
+        catch (WebSocketException wsEx) when (wsEx.WebSocketErrorCode == WebSocketError.ConnectionClosedPrematurely)
+        {
+            _logger.LogWarning("⚠️ WEBSOCKET {Direction}: Connection closed prematurely", direction);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "⚠️ WEBSOCKET {Direction}: Error proxying messages", direction);
+        }
+    }
+}

allstarr/Models/Domain/Song.cs

@@ -14,6 +14,11 @@ public class Song
     public string Title { get; set; } = string.Empty;
     public string Artist { get; set; } = string.Empty;
     public string? ArtistId { get; set; }
+    
+    /// <summary>
+    /// All artists for this track (main + featured). For display in Jellyfin clients.
+    /// </summary>
+    public List<string> Artists { get; set; } = new();
     public string Album { get; set; } = string.Empty;
     public string? AlbumId { get; set; }
     public int? Duration { get; set; } // In seconds

allstarr/Models/Settings/SpotifyImportSettings.cs

@@ -0,0 +1,121 @@
+namespace allstarr.Models.Settings;
+
+/// <summary>
+/// Where to position local tracks relative to external matched tracks in Spotify playlists.
+/// </summary>
+public enum LocalTracksPosition
+{
+    /// <summary>
+    /// Local tracks appear first, external tracks appended at the end (default)
+    /// </summary>
+    First,
+    
+    /// <summary>
+    /// External tracks appear first, local tracks appended at the end
+    /// </summary>
+    Last
+}
+
+/// <summary>
+/// Configuration for a single Spotify Import playlist.
+/// </summary>
+public class SpotifyPlaylistConfig
+{
+    /// <summary>
+    /// Playlist name as it appears in Jellyfin/Spotify Import plugin
+    /// Example: "Discover Weekly", "Release Radar"
+    /// </summary>
+    public string Name { get; set; } = string.Empty;
+    
+    /// <summary>
+    /// Jellyfin playlist ID (get from playlist URL)
+    /// Example: "4383a46d8bcac3be2ef9385053ea18df"
+    /// </summary>
+    public string Id { get; set; } = string.Empty;
+    
+    /// <summary>
+    /// Where to position local tracks: "first" or "last"
+    /// </summary>
+    public LocalTracksPosition LocalTracksPosition { get; set; } = LocalTracksPosition.First;
+}
+
+/// <summary>
+/// Configuration for Spotify playlist injection feature.
+/// Requires Jellyfin Spotify Import Plugin: https://github.com/Viperinius/jellyfin-plugin-spotify-import
+/// Uses JellyfinSettings.Url and JellyfinSettings.ApiKey for API access.
+/// </summary>
+public class SpotifyImportSettings
+{
+    /// <summary>
+    /// Enable Spotify playlist injection feature
+    /// </summary>
+    public bool Enabled { get; set; }
+    
+    /// <summary>
+    /// Hour when Spotify Import plugin runs (24-hour format, 0-23)
+    /// NOTE: This setting is now optional and only used for the sync window check.
+    /// The fetcher will search backwards from current time for the last 48 hours,
+    /// so timezone confusion is avoided.
+    /// </summary>
+    public int SyncStartHour { get; set; } = 16;
+    
+    /// <summary>
+    /// Minute when Spotify Import plugin runs (0-59)
+    /// NOTE: This setting is now optional and only used for the sync window check.
+    /// </summary>
+    public int SyncStartMinute { get; set; } = 15;
+    
+    /// <summary>
+    /// How many hours to search for missing tracks files after sync start time
+    /// This prevents the fetcher from running too frequently.
+    /// Set to 0 to disable the sync window check and always search on startup.
+    /// </summary>
+    public int SyncWindowHours { get; set; } = 2;
+    
+    /// <summary>
+    /// Combined playlist configuration as JSON array.
+    /// Format: [["Name","Id","first|last"],...]
+    /// Example: [["Discover Weekly","abc123","first"],["Release Radar","def456","last"]]
+    /// </summary>
+    public List<SpotifyPlaylistConfig> Playlists { get; set; } = new();
+    
+    /// <summary>
+    /// Legacy: Comma-separated list of Jellyfin playlist IDs to inject
+    /// Deprecated: Use Playlists instead
+    /// </summary>
+    [Obsolete("Use Playlists instead")]
+    public List<string> PlaylistIds { get; set; } = new();
+    
+    /// <summary>
+    /// Legacy: Comma-separated list of playlist names
+    /// Deprecated: Use Playlists instead
+    /// </summary>
+    [Obsolete("Use Playlists instead")]
+    public List<string> PlaylistNames { get; set; } = new();
+    
+    /// <summary>
+    /// Legacy: Comma-separated list of local track positions ("first" or "last")
+    /// Deprecated: Use Playlists instead
+    /// Example: "first,last,first,first" (one per playlist)
+    /// </summary>
+    [Obsolete("Use Playlists instead")]
+    public List<string> PlaylistLocalTracksPositions { get; set; } = new();
+    
+    /// <summary>
+    /// Gets the playlist configuration by Jellyfin playlist ID.
+    /// </summary>
+    public SpotifyPlaylistConfig? GetPlaylistById(string playlistId) =>
+        Playlists.FirstOrDefault(p => p.Id.Equals(playlistId, StringComparison.OrdinalIgnoreCase));
+    
+    /// <summary>
+    /// Gets the playlist configuration by name.
+    /// </summary>
+    public SpotifyPlaylistConfig? GetPlaylistByName(string name) =>
+        Playlists.FirstOrDefault(p => p.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
+    
+    /// <summary>
+    /// Checks if a playlist ID is configured for Spotify import.
+    /// </summary>
+    public bool IsSpotifyPlaylist(string playlistId) =>
+        Playlists.Any(p => p.Id.Equals(playlistId, StringComparison.OrdinalIgnoreCase));
+}

allstarr/Models/Spotify/MissingTrack.cs

@@ -0,0 +1,12 @@
+namespace allstarr.Models.Spotify;
+
+public class MissingTrack
+{
+    public string SpotifyId { get; set; } = string.Empty;
+    public string Title { get; set; } = string.Empty;
+    public string Album { get; set; } = string.Empty;
+    public List<string> Artists { get; set; } = new();
+    
+    public string PrimaryArtist => Artists.FirstOrDefault() ?? "";
+    public string AllArtists => string.Join(", ", Artists);
+}

allstarr/Program.cs

@@ -22,12 +22,16 @@ static List<string> DecodeSquidWtfUrls()
 {
     var encodedUrls = new[]
     {
-        "aHR0cHM6Ly90cml0b24uc3F1aWQud3Rm",      // triton
-        "aHR0cHM6Ly93b2xmLnFxZGwuc2l0ZQ==",      // wolf
-        "aHR0cDovL2h1bmQucXFkbC5zaXRl",          // hund
-        "aHR0cHM6Ly9tYXVzLnFxZGwuc2l0ZQ==",      // maus
-        "aHR0cHM6Ly92b2dlbC5xcWRsLnNpdGU=",      // vogel
-        "aHR0cHM6Ly9rYXR6ZS5xcWRsLnNpdGU="       // katze
+        "aHR0cHM6Ly90cml0b24uc3F1aWQud3Rm",                      // triton
+        "aHR0cHM6Ly90aWRhbC1hcGkuYmluaW11bS5vcmc=",              // binimum
+        "aHR0cHM6Ly90aWRhbC5raW5vcGx1cy5vbmxpbmU=",              // kinoplus
+        "aHR0cHM6Ly9oaWZpLXR3by5zcG90aXNhdmVyLm5ldA==",          // spoti-2
+        "aHR0cHM6Ly9oaWZpLW9uZS5zcG90aXNhdmVyLm5ldA==",          // spoti-1
+        "aHR0cHM6Ly93b2xmLnFxZGwuc2l0ZQ==",                      // wolf
+        "aHR0cDovL2h1bmQucXFkbC5zaXRl",                          // hund
+        "aHR0cHM6Ly9rYXR6ZS5xcWRsLnNpdGU=",                      // katze
+        "aHR0cHM6Ly92b2dlbC5xcWRsLnNpdGU=",                      // vogel
+        "aHR0cHM6Ly9tYXVzLnFxZGwuc2l0ZQ=="                       // maus
     };
     
     return encodedUrls
@@ -108,6 +112,234 @@ builder.Services.Configure<SquidWTFSettings>(
     builder.Configuration.GetSection("SquidWTF"));
 builder.Services.Configure<RedisSettings>(
     builder.Configuration.GetSection("Redis"));
+// Configure Spotify Import settings with custom playlist parsing from env var
+builder.Services.Configure<SpotifyImportSettings>(options =>
+{
+    builder.Configuration.GetSection("SpotifyImport").Bind(options);
+    
+    // Debug: Check what Bind() populated
+    Console.WriteLine($"DEBUG: After Bind(), Playlists.Count = {options.Playlists.Count}");
+    Console.WriteLine($"DEBUG: After Bind(), PlaylistIds.Count = {options.PlaylistIds.Count}");
+    Console.WriteLine($"DEBUG: After Bind(), PlaylistNames.Count = {options.PlaylistNames.Count}");
+    
+    // Parse SPOTIFY_IMPORT_PLAYLISTS env var (JSON array format)
+    // Format: [["Name","Id","first|last"],["Name2","Id2","first|last"]]
+    var playlistsEnv = builder.Configuration.GetValue<string>("SpotifyImport:Playlists");
+    if (!string.IsNullOrWhiteSpace(playlistsEnv))
+    {
+        Console.WriteLine($"Found SPOTIFY_IMPORT_PLAYLISTS env var: {playlistsEnv.Length} chars");
+        try
+        {
+            // Parse as JSON array of arrays
+            var playlistArrays = System.Text.Json.JsonSerializer.Deserialize<string[][]>(playlistsEnv);
+            if (playlistArrays != null && playlistArrays.Length > 0)
+            {
+                Console.WriteLine($"Parsed {playlistArrays.Length} playlists from JSON format");
+                foreach (var arr in playlistArrays)
+                {
+                    if (arr.Length >= 2)
+                    {
+                        var config = new SpotifyPlaylistConfig
+                        {
+                            Name = arr[0].Trim(),
+                            Id = arr[1].Trim(),
+                            LocalTracksPosition = arr.Length >= 3 && 
+                                arr[2].Trim().Equals("last", StringComparison.OrdinalIgnoreCase)
+                                ? LocalTracksPosition.Last
+                                : LocalTracksPosition.First
+                        };
+                        options.Playlists.Add(config);
+                        Console.WriteLine($"  Added: {config.Name} (ID: {config.Id}, Position: {config.LocalTracksPosition})");
+                    }
+                }
+            }
+            else
+            {
+                Console.WriteLine("JSON format was empty or invalid, will try legacy format");
+            }
+        }
+        catch (System.Text.Json.JsonException ex)
+        {
+            Console.WriteLine($"Warning: Failed to parse SPOTIFY_IMPORT_PLAYLISTS: {ex.Message}");
+            Console.WriteLine("Expected format: [[\"Name\",\"Id\",\"first|last\"],[\"Name2\",\"Id2\",\"first|last\"]]");
+            Console.WriteLine("Will try legacy format instead");
+        }
+    }
+    else
+    {
+        Console.WriteLine("No SPOTIFY_IMPORT_PLAYLISTS env var found, will try legacy format");
+    }
+    
+    // Legacy support: Parse old SPOTIFY_IMPORT_PLAYLIST_IDS/NAMES env vars
+    // Only used if new Playlists format is not configured
+    // Check if we have legacy env vars to parse
+    var playlistIdsEnv = builder.Configuration.GetValue<string>("SpotifyImport:PlaylistIds");
+    var playlistNamesEnv = builder.Configuration.GetValue<string>("SpotifyImport:PlaylistNames");
+    var hasLegacyConfig = !string.IsNullOrWhiteSpace(playlistIdsEnv) || !string.IsNullOrWhiteSpace(playlistNamesEnv);
+    
+    if (hasLegacyConfig && options.Playlists.Count == 0)
+    {
+        Console.WriteLine("Parsing legacy Spotify playlist format...");
+        
+        #pragma warning disable CS0618 // Type or member is obsolete
+        
+        // Clear any auto-bound values from the Bind() call above
+        // The auto-binder doesn't handle comma-separated strings correctly
+        options.PlaylistIds.Clear();
+        options.PlaylistNames.Clear();
+        options.PlaylistLocalTracksPositions.Clear();
+        
+        if (!string.IsNullOrWhiteSpace(playlistIdsEnv))
+        {
+            options.PlaylistIds = playlistIdsEnv
+                .Split(',', StringSplitOptions.RemoveEmptyEntries)
+                .Select(id => id.Trim())
+                .Where(id => !string.IsNullOrEmpty(id))
+                .ToList();
+            Console.WriteLine($"  Parsed {options.PlaylistIds.Count} playlist IDs from env var");
+        }
+        
+        if (!string.IsNullOrWhiteSpace(playlistNamesEnv))
+        {
+            options.PlaylistNames = playlistNamesEnv
+                .Split(',', StringSplitOptions.RemoveEmptyEntries)
+                .Select(name => name.Trim())
+                .Where(name => !string.IsNullOrEmpty(name))
+                .ToList();
+            Console.WriteLine($"  Parsed {options.PlaylistNames.Count} playlist names from env var");
+        }
+        
+        var playlistPositionsEnv = builder.Configuration.GetValue<string>("SpotifyImport:PlaylistLocalTracksPositions");
+        if (!string.IsNullOrWhiteSpace(playlistPositionsEnv))
+        {
+            options.PlaylistLocalTracksPositions = playlistPositionsEnv
+                .Split(',', StringSplitOptions.RemoveEmptyEntries)
+                .Select(pos => pos.Trim())
+                .Where(pos => !string.IsNullOrEmpty(pos))
+                .ToList();
+            Console.WriteLine($"  Parsed {options.PlaylistLocalTracksPositions.Count} playlist positions from env var");
+        }
+        else
+        {
+            Console.WriteLine("  No playlist positions env var found, will use defaults");
+        }
+        
+        // Convert legacy format to new Playlists array
+        Console.WriteLine($"  Converting {options.PlaylistIds.Count} playlists to new format...");
+        for (int i = 0; i < options.PlaylistIds.Count; i++)
+        {
+            var name = i < options.PlaylistNames.Count ? options.PlaylistNames[i] : options.PlaylistIds[i];
+            var position = LocalTracksPosition.First; // Default
+            
+            // Parse position if provided
+            if (i < options.PlaylistLocalTracksPositions.Count)
+            {
+                var posStr = options.PlaylistLocalTracksPositions[i];
+                if (posStr.Equals("last", StringComparison.OrdinalIgnoreCase))
+                {
+                    position = LocalTracksPosition.Last;
+                }
+            }
+            
+            options.Playlists.Add(new SpotifyPlaylistConfig
+            {
+                Name = name,
+                Id = options.PlaylistIds[i],
+                LocalTracksPosition = position
+            });
+            Console.WriteLine($"    [{i}] {name} (ID: {options.PlaylistIds[i]}, Position: {position})");
+        }
+        #pragma warning restore CS0618
+    }
+    else if (hasLegacyConfig && options.Playlists.Count > 0)
+    {
+        // Bind() incorrectly populated Playlists from legacy env vars
+        // Clear it and re-parse properly
+        Console.WriteLine($"DEBUG: Bind() incorrectly populated {options.Playlists.Count} playlists, clearing and re-parsing...");
+        options.Playlists.Clear();
+        options.PlaylistIds.Clear();
+        options.PlaylistNames.Clear();
+        options.PlaylistLocalTracksPositions.Clear();
+        
+        Console.WriteLine("Parsing legacy Spotify playlist format...");
+        
+        #pragma warning disable CS0618 // Type or member is obsolete
+        
+        if (!string.IsNullOrWhiteSpace(playlistIdsEnv))
+        {
+            options.PlaylistIds = playlistIdsEnv
+                .Split(',', StringSplitOptions.RemoveEmptyEntries)
+                .Select(id => id.Trim())
+                .Where(id => !string.IsNullOrEmpty(id))
+                .ToList();
+            Console.WriteLine($"  Parsed {options.PlaylistIds.Count} playlist IDs from env var");
+        }
+        
+        if (!string.IsNullOrWhiteSpace(playlistNamesEnv))
+        {
+            options.PlaylistNames = playlistNamesEnv
+                .Split(',', StringSplitOptions.RemoveEmptyEntries)
+                .Select(name => name.Trim())
+                .Where(name => !string.IsNullOrEmpty(name))
+                .ToList();
+            Console.WriteLine($"  Parsed {options.PlaylistNames.Count} playlist names from env var");
+        }
+        
+        var playlistPositionsEnv = builder.Configuration.GetValue<string>("SpotifyImport:PlaylistLocalTracksPositions");
+        if (!string.IsNullOrWhiteSpace(playlistPositionsEnv))
+        {
+            options.PlaylistLocalTracksPositions = playlistPositionsEnv
+                .Split(',', StringSplitOptions.RemoveEmptyEntries)
+                .Select(pos => pos.Trim())
+                .Where(pos => !string.IsNullOrEmpty(pos))
+                .ToList();
+            Console.WriteLine($"  Parsed {options.PlaylistLocalTracksPositions.Count} playlist positions from env var");
+        }
+        else
+        {
+            Console.WriteLine("  No playlist positions env var found, will use defaults");
+        }
+        
+        // Convert legacy format to new Playlists array
+        Console.WriteLine($"  Converting {options.PlaylistIds.Count} playlists to new format...");
+        for (int i = 0; i < options.PlaylistIds.Count; i++)
+        {
+            var name = i < options.PlaylistNames.Count ? options.PlaylistNames[i] : options.PlaylistIds[i];
+            var position = LocalTracksPosition.First; // Default
+            
+            // Parse position if provided
+            if (i < options.PlaylistLocalTracksPositions.Count)
+            {
+                var posStr = options.PlaylistLocalTracksPositions[i];
+                if (posStr.Equals("last", StringComparison.OrdinalIgnoreCase))
+                {
+                    position = LocalTracksPosition.Last;
+                }
+            }
+            
+            options.Playlists.Add(new SpotifyPlaylistConfig
+            {
+                Name = name,
+                Id = options.PlaylistIds[i],
+                LocalTracksPosition = position
+            });
+            Console.WriteLine($"    [{i}] {name} (ID: {options.PlaylistIds[i]}, Position: {position})");
+        }
+        #pragma warning restore CS0618
+    }
+    else
+    {
+        Console.WriteLine($"Using new Playlists format: {options.Playlists.Count} playlists configured");
+    }
+    
+    // Log configuration at startup
+    Console.WriteLine($"Spotify Import: Enabled={options.Enabled}, SyncHour={options.SyncStartHour}:{options.SyncStartMinute:D2}, WindowHours={options.SyncWindowHours}");
+    Console.WriteLine($"Spotify Import Playlists: {options.Playlists.Count} configured");
+    foreach (var playlist in options.Playlists)
+    {
+        Console.WriteLine($"  - {playlist.Name} (ID: {playlist.Id}, LocalTracks: {playlist.LocalTracksPosition})");
+    }
+});
 
 // Get shared settings from the active backend config
 MusicService musicService;
@@ -137,7 +369,9 @@ if (backendType == BackendType.Jellyfin)
     builder.Services.AddSingleton<JellyfinResponseBuilder>();
     builder.Services.AddSingleton<JellyfinModelMapper>();
     builder.Services.AddScoped<JellyfinProxyService>();
+    builder.Services.AddSingleton<JellyfinSessionManager>();
     builder.Services.AddScoped<JellyfinAuthFilter>();
+    builder.Services.AddScoped<allstarr.Filters.ApiKeyAuthFilter>();
 }
 else
 {
@@ -229,6 +463,12 @@ builder.Services.AddHostedService<StartupValidationOrchestrator>();
 // Register cache cleanup service (only runs when StorageMode is Cache)
 builder.Services.AddHostedService<CacheCleanupService>();
 
+// Register Spotify missing tracks fetcher (only runs when SpotifyImport is enabled)
+builder.Services.AddHostedService<allstarr.Services.Spotify.SpotifyMissingTracksFetcher>();
+
+// Register Spotify track matching service (pre-matches tracks with rate limiting)
+builder.Services.AddHostedService<allstarr.Services.Spotify.SpotifyTrackMatchingService>();
+
 builder.Services.AddCors(options =>
 {
     options.AddDefaultPolicy(policy =>
@@ -248,6 +488,15 @@ app.UseExceptionHandler(_ => { }); // Global exception handler
 // Enable response compression EARLY in the pipeline
 app.UseResponseCompression();
 
+// Enable WebSocket support
+app.UseWebSockets(new WebSocketOptions
+{
+    KeepAliveInterval = TimeSpan.FromSeconds(120)
+});
+
+// Add WebSocket proxy middleware (BEFORE routing)
+app.UseMiddleware<WebSocketProxyMiddleware>();
+
 if (app.Environment.IsDevelopment())
 {
     app.UseSwagger();

allstarr/Services/Jellyfin/JellyfinProxyService.cs

@@ -103,8 +103,9 @@ public class JellyfinProxyService
     /// <summary>
     /// Sends a GET request to the Jellyfin server.
     /// If endpoint already contains query parameters, they will be preserved and merged with queryParams.
+    /// Returns the response body and HTTP status code.
     /// </summary>
-    public async Task<JsonDocument?> GetJsonAsync(string endpoint, Dictionary<string, string>? queryParams = null, IHeaderDictionary? clientHeaders = null)
+    public async Task<(JsonDocument? Body, int StatusCode)> GetJsonAsync(string endpoint, Dictionary<string, string>? queryParams = null, IHeaderDictionary? clientHeaders = null)
     {
         // If endpoint contains query string, parse and merge with queryParams
         if (endpoint.Contains('?'))
@@ -141,12 +142,32 @@ public class JellyfinProxyService
         return await GetJsonAsyncInternal(finalUrl, clientHeaders);
     }
     
-    private async Task<JsonDocument?> GetJsonAsyncInternal(string url, IHeaderDictionary? clientHeaders)
+    private async Task<(JsonDocument? Body, int StatusCode)> GetJsonAsyncInternal(string url, IHeaderDictionary? clientHeaders)
     {
         using var request = new HttpRequestMessage(HttpMethod.Get, url);
         
+        // Forward client IP address to Jellyfin so it can identify the real client
+        if (_httpContextAccessor.HttpContext != null)
+        {
+            var clientIp = _httpContextAccessor.HttpContext.Connection.RemoteIpAddress?.ToString();
+            if (!string.IsNullOrEmpty(clientIp))
+            {
+                request.Headers.TryAddWithoutValidation("X-Forwarded-For", clientIp);
+                request.Headers.TryAddWithoutValidation("X-Real-IP", clientIp);
+            }
+        }
+        
         bool authHeaderAdded = false;
         
+        // Check if this is a browser request for static assets (favicon, etc.)
+        bool isBrowserStaticRequest = url.Contains("/favicon.ico", StringComparison.OrdinalIgnoreCase) ||
+                                      url.Contains("/web/", StringComparison.OrdinalIgnoreCase) ||
+                                      (clientHeaders?.Any(h => h.Key.Equals("User-Agent", StringComparison.OrdinalIgnoreCase) && 
+                                                              h.Value.ToString().Contains("Mozilla", StringComparison.OrdinalIgnoreCase)) == true &&
+                                       clientHeaders?.Any(h => h.Key.Equals("sec-fetch-dest", StringComparison.OrdinalIgnoreCase) && 
+                                                              (h.Value.ToString().Contains("image", StringComparison.OrdinalIgnoreCase) ||
+                                                               h.Value.ToString().Contains("document", StringComparison.OrdinalIgnoreCase))) == true);
+        
         // Forward authentication headers from client if provided
         if (clientHeaders != null && clientHeaders.Count > 0)
         {
@@ -194,35 +215,31 @@ public class JellyfinProxyService
                 }
             }
             
-            if (!authHeaderAdded)
+            // Only log warnings for non-browser static requests
+            if (!authHeaderAdded && !isBrowserStaticRequest)
             {
                 _logger.LogWarning("✗ No auth header found. Available headers: {Headers}", 
                     string.Join(", ", clientHeaders.Select(h => $"{h.Key}={h.Value}")));
             }
         }
-        else
+        else if (!isBrowserStaticRequest)
         {
             _logger.LogWarning("✗ No client headers provided for {Url}", url);
         }
         
-        // Use API key if no valid client auth was found
-        if (!authHeaderAdded)
+        // DO NOT use server API key as fallback - let Jellyfin handle unauthenticated requests
+        // If client doesn't provide auth, they get what they deserve (401 from Jellyfin)
+        if (!authHeaderAdded && !isBrowserStaticRequest)
         {
-            if (!string.IsNullOrEmpty(_settings.ApiKey))
-            {
-                request.Headers.Add("Authorization", GetAuthorizationHeader());
-                _logger.LogInformation("→ Using API key for {Url}", url);
-            }
-            else
-            {
-                _logger.LogWarning("✗ No authentication available for {Url} - request will fail", url);
-            }
+            _logger.LogInformation("No client auth provided for {Url} - forwarding without auth", url);
         }
         
         request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
 
         var response = await _httpClient.SendAsync(request);
         
+        var statusCode = (int)response.StatusCode;
+        
         // Always parse the response, even for errors
         // The caller needs to see 401s so the client can re-authenticate
         var content = await response.Content.ReadAsStringAsync();
@@ -233,29 +250,40 @@ public class JellyfinProxyService
             {
                 _logger.LogWarning("Jellyfin returned 401 Unauthorized for {Url} - passing through to client", url);
             }
-            else
+            else if (!isBrowserStaticRequest) // Don't log 404s for browser static requests
             {
                 _logger.LogWarning("Jellyfin request failed: {StatusCode} for {Url}", response.StatusCode, url);
             }
             
-            // Return null so caller knows request failed
-            // TODO: We should return the status code too so caller can pass it through
-            return null;
+            // Return null body with the actual status code
+            return (null, statusCode);
         }
 
-        return JsonDocument.Parse(content);
+        return (JsonDocument.Parse(content), statusCode);
     }
 
     /// <summary>
     /// Sends a POST request to the Jellyfin server with JSON body.
     /// Forwards client headers for authentication passthrough.
+    /// Returns the response body and HTTP status code.
     /// </summary>
-    public async Task<JsonDocument?> PostJsonAsync(string endpoint, string body, IHeaderDictionary clientHeaders)
+    public async Task<(JsonDocument? Body, int StatusCode)> PostJsonAsync(string endpoint, string body, IHeaderDictionary clientHeaders)
     {
         var url = BuildUrl(endpoint, null);
         
         using var request = new HttpRequestMessage(HttpMethod.Post, url);
         
+        // Forward client IP address to Jellyfin so it can identify the real client
+        if (_httpContextAccessor.HttpContext != null)
+        {
+            var clientIp = _httpContextAccessor.HttpContext.Connection.RemoteIpAddress?.ToString();
+            if (!string.IsNullOrEmpty(clientIp))
+            {
+                request.Headers.TryAddWithoutValidation("X-Forwarded-For", clientIp);
+                request.Headers.TryAddWithoutValidation("X-Real-IP", clientIp);
+            }
+        }
+        
         // Handle special case for playback endpoints - Jellyfin expects wrapped body
         var bodyToSend = body;
         if (!string.IsNullOrWhiteSpace(body))
@@ -297,8 +325,10 @@ public class JellyfinProxyService
         {
             if (header.Key.Equals("X-Emby-Authorization", StringComparison.OrdinalIgnoreCase))
             {
-                request.Headers.TryAddWithoutValidation("X-Emby-Authorization", header.Value.ToString());
+                var headerValue = header.Value.ToString();
+                request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue);
                 authHeaderAdded = true;
+                _logger.LogDebug("Forwarded X-Emby-Authorization from client");
                 break;
             }
         }
@@ -309,21 +339,34 @@ public class JellyfinProxyService
             {
                 if (header.Key.Equals("Authorization", StringComparison.OrdinalIgnoreCase))
                 {
-                    request.Headers.TryAddWithoutValidation("Authorization", header.Value.ToString());
+                    var headerValue = header.Value.ToString();
+                    
+                    // Check if it's MediaBrowser/Jellyfin format
+                    if (headerValue.Contains("MediaBrowser", StringComparison.OrdinalIgnoreCase) || 
+                        headerValue.Contains("Client=", StringComparison.OrdinalIgnoreCase))
+                    {
+                        // Forward as X-Emby-Authorization
+                        request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue);
+                        _logger.LogDebug("Converted Authorization to X-Emby-Authorization");
+                    }
+                    else
+                    {
+                        // Standard Bearer token
+                        request.Headers.TryAddWithoutValidation("Authorization", headerValue);
+                        _logger.LogDebug("Forwarded Authorization header");
+                    }
                     authHeaderAdded = true;
                     break;
                 }
             }
         }
         
-        // For login requests without auth headers, provide a minimal client auth header
+        // DO NOT use server credentials as fallback
+        // Exception: For auth endpoints, client provides their own credentials in the body
+        // For all other endpoints, if client doesn't provide auth, let Jellyfin reject it
         if (!authHeaderAdded)
         {
-            var clientAuthHeader = $"MediaBrowser Client=\"{_settings.ClientName}\", " +
-                                   $"Device=\"{_settings.DeviceName}\", " +
-                                   $"DeviceId=\"{_settings.DeviceId}\", " +
-                                   $"Version=\"{_settings.ClientVersion}\"";
-            request.Headers.TryAddWithoutValidation("X-Emby-Authorization", clientAuthHeader);
+            _logger.LogInformation("No client auth provided for POST {Url} - forwarding without auth", url);
         }
         
         request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
@@ -346,18 +389,26 @@ public class JellyfinProxyService
         
         var response = await _httpClient.SendAsync(request);
         
+        var statusCode = (int)response.StatusCode;
+        
         if (!response.IsSuccessStatusCode)
         {
             var errorContent = await response.Content.ReadAsStringAsync();
-            _logger.LogWarning("Jellyfin POST request failed: {StatusCode} for {Url}. Response: {Response}", 
+            _logger.LogWarning("❌ SESSION: Jellyfin POST request failed: {StatusCode} for {Url}. Response: {Response}", 
                 response.StatusCode, url, errorContent);
-            return null;
+            return (null, statusCode);
+        }
+
+        // Log successful session-related responses
+        if (endpoint.Contains("Sessions", StringComparison.OrdinalIgnoreCase))
+        {
+            _logger.LogWarning("✓ SESSION: Jellyfin responded {StatusCode} for {Endpoint}", statusCode, endpoint);
         }
 
         // Handle 204 No Content responses (e.g., /sessions/playing, /sessions/playing/progress)
         if (response.StatusCode == System.Net.HttpStatusCode.NoContent)
         {
-            return null;
+            return (null, statusCode);
         }
 
         var responseContent = await response.Content.ReadAsStringAsync();
@@ -365,10 +416,17 @@ public class JellyfinProxyService
         // Handle empty responses
         if (string.IsNullOrWhiteSpace(responseContent))
         {
-            return null;
+            return (null, statusCode);
         }
         
-        return JsonDocument.Parse(responseContent);
+        // Log response content for session endpoints
+        if (endpoint.Contains("Sessions", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(responseContent))
+        {
+            var preview = responseContent.Length > 200 ? responseContent[..200] + "..." : responseContent;
+            _logger.LogWarning("📥 SESSION: Jellyfin response body: {Body}", preview);
+        }
+        
+        return (JsonDocument.Parse(responseContent), statusCode);
     }
 
     /// <summary>
@@ -390,6 +448,109 @@ public class JellyfinProxyService
         return (body, contentType);
     }
 
+    /// <summary>
+    /// Sends a DELETE request to the Jellyfin server.
+    /// Forwards client headers for authentication passthrough.
+    /// Returns the response body and HTTP status code.
+    /// </summary>
+    public async Task<(JsonDocument? Body, int StatusCode)> DeleteAsync(string endpoint, IHeaderDictionary clientHeaders)
+    {
+        var url = BuildUrl(endpoint, null);
+        
+        using var request = new HttpRequestMessage(HttpMethod.Delete, url);
+        
+        // Forward client IP address to Jellyfin so it can identify the real client
+        if (_httpContextAccessor.HttpContext != null)
+        {
+            var clientIp = _httpContextAccessor.HttpContext.Connection.RemoteIpAddress?.ToString();
+            if (!string.IsNullOrEmpty(clientIp))
+            {
+                request.Headers.TryAddWithoutValidation("X-Forwarded-For", clientIp);
+                request.Headers.TryAddWithoutValidation("X-Real-IP", clientIp);
+            }
+        }
+        
+        bool authHeaderAdded = false;
+        
+        // Forward authentication headers from client (case-insensitive)
+        foreach (var header in clientHeaders)
+        {
+            if (header.Key.Equals("X-Emby-Authorization", StringComparison.OrdinalIgnoreCase))
+            {
+                var headerValue = header.Value.ToString();
+                request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue);
+                authHeaderAdded = true;
+                _logger.LogDebug("Forwarded X-Emby-Authorization from client");
+                break;
+            }
+        }
+        
+        if (!authHeaderAdded)
+        {
+            foreach (var header in clientHeaders)
+            {
+                if (header.Key.Equals("Authorization", StringComparison.OrdinalIgnoreCase))
+                {
+                    var headerValue = header.Value.ToString();
+                    
+                    // Check if it's MediaBrowser/Jellyfin format
+                    if (headerValue.Contains("MediaBrowser", StringComparison.OrdinalIgnoreCase) || 
+                        headerValue.Contains("Client=", StringComparison.OrdinalIgnoreCase))
+                    {
+                        // Forward as X-Emby-Authorization
+                        request.Headers.TryAddWithoutValidation("X-Emby-Authorization", headerValue);
+                        _logger.LogDebug("Converted Authorization to X-Emby-Authorization");
+                    }
+                    else
+                    {
+                        // Standard Bearer token
+                        request.Headers.TryAddWithoutValidation("Authorization", headerValue);
+                        _logger.LogDebug("Forwarded Authorization header");
+                    }
+                    authHeaderAdded = true;
+                    break;
+                }
+            }
+        }
+        
+        if (!authHeaderAdded)
+        {
+            _logger.LogInformation("No client auth provided for DELETE {Url} - forwarding without auth", url);
+        }
+        
+        request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+        
+        _logger.LogInformation("DELETE to Jellyfin: {Url}", url);
+        
+        var response = await _httpClient.SendAsync(request);
+        
+        var statusCode = (int)response.StatusCode;
+        
+        if (!response.IsSuccessStatusCode)
+        {
+            var errorContent = await response.Content.ReadAsStringAsync();
+            _logger.LogWarning("Jellyfin DELETE request failed: {StatusCode} for {Url}. Response: {Response}", 
+                response.StatusCode, url, errorContent);
+            return (null, statusCode);
+        }
+
+        // Handle 204 No Content responses
+        if (response.StatusCode == System.Net.HttpStatusCode.NoContent)
+        {
+            return (null, statusCode);
+        }
+
+        var responseContent = await response.Content.ReadAsStringAsync();
+        
+        // Handle empty responses
+        if (string.IsNullOrWhiteSpace(responseContent))
+        {
+            return (null, statusCode);
+        }
+        
+        return (JsonDocument.Parse(responseContent), statusCode);
+    }
+
     /// <summary>
     /// Safely sends a GET request to the Jellyfin server, returning null on failure.
     /// </summary>
@@ -413,7 +574,7 @@ public class JellyfinProxyService
     /// Searches for items in Jellyfin.
     /// Uses configured or auto-detected LibraryId to filter search to music library only.
     /// </summary>
-    public async Task<JsonDocument?> SearchAsync(
+    public async Task<(JsonDocument? Body, int StatusCode)> SearchAsync(
         string searchTerm,
         string[]? includeItemTypes = null,
         int limit = 20,
@@ -451,7 +612,7 @@ public class JellyfinProxyService
     /// <summary>
     /// Gets items from a specific parent (album, artist, playlist).
     /// </summary>
-    public async Task<JsonDocument?> GetItemsAsync(
+    public async Task<(JsonDocument? Body, int StatusCode)> GetItemsAsync(
         string? parentId = null,
         string[]? includeItemTypes = null,
         string? sortBy = null,
@@ -507,7 +668,7 @@ public class JellyfinProxyService
     /// <summary>
     /// Gets a single item by ID.
     /// </summary>
-    public async Task<JsonDocument?> GetItemAsync(string itemId, IHeaderDictionary? clientHeaders = null)
+    public async Task<(JsonDocument? Body, int StatusCode)> GetItemAsync(string itemId, IHeaderDictionary? clientHeaders = null)
     {
         var queryParams = new Dictionary<string, string>();
         
@@ -522,7 +683,7 @@ public class JellyfinProxyService
     /// <summary>
     /// Gets artists from the library.
     /// </summary>
-    public async Task<JsonDocument?> GetArtistsAsync(
+    public async Task<(JsonDocument? Body, int StatusCode)> GetArtistsAsync(
         string? searchTerm = null,
         int? limit = null,
         int? startIndex = null,
@@ -559,7 +720,7 @@ public class JellyfinProxyService
     /// <summary>
     /// Gets an artist by name or ID.
     /// </summary>
-    public async Task<JsonDocument?> GetArtistAsync(string artistIdOrName, IHeaderDictionary? clientHeaders = null)
+    public async Task<(JsonDocument? Body, int StatusCode)> GetArtistAsync(string artistIdOrName, IHeaderDictionary? clientHeaders = null)
     {
         var queryParams = new Dictionary<string, string>();
         
@@ -720,8 +881,8 @@ public class JellyfinProxyService
     {
         try
         {
-            var result = await GetJsonAsync("System/Info/Public");
-            if (result == null)
+            var (result, statusCode) = await GetJsonAsync("System/Info/Public");
+            if (result == null || statusCode != 200)
             {
                 return (false, null, null);
             }
@@ -755,7 +916,7 @@ public class JellyfinProxyService
                 queryParams["userId"] = _settings.UserId;
             }
 
-            var result = await GetJsonAsync("Library/MediaFolders", queryParams);
+            var (result, statusCode) = await GetJsonAsync("Library/MediaFolders", queryParams);
             if (result == null)
             {
                 return null;

allstarr/Services/Jellyfin/JellyfinResponseBuilder.cs

@@ -186,7 +186,7 @@ public class JellyfinResponseBuilder
                 ["Type"] = "Audio",
                 ["Album"] = song.Album,
                 ["AlbumArtist"] = song.Artist,
-                ["Artists"] = new[] { song.Artist },
+                ["Artists"] = song.Artists.Count > 0 ? song.Artists.ToArray() : new[] { song.Artist },
                 ["RunTimeTicks"] = (song.Duration ?? 0) * TimeSpan.TicksPerSecond,
                 ["ImageTags"] = new Dictionary<string, string>
                 {
@@ -242,15 +242,23 @@ public class JellyfinResponseBuilder
             ["Album"] = song.Album,
             ["AlbumId"] = song.AlbumId ?? song.Id,
             ["AlbumArtist"] = song.AlbumArtist ?? song.Artist,
-            ["Artists"] = new[] { song.Artist },
-            ["ArtistItems"] = new[]
-            {
-                new Dictionary<string, object?>
+            ["Artists"] = song.Artists.Count > 0 ? song.Artists.ToArray() : new[] { song.Artist },
+            ["ArtistItems"] = song.Artists.Count > 0 
+                ? song.Artists.Select((name, index) => new Dictionary<string, object?>
                 {
-                    ["Id"] = song.ArtistId ?? song.Id,
-                    ["Name"] = song.Artist
-                }
-            },
+                    ["Name"] = name,
+                    ["Id"] = index == 0 && song.ArtistId != null 
+                        ? song.ArtistId 
+                        : $"{song.Id}-artist-{index}"
+                }).ToArray()
+                : new[]
+                {
+                    new Dictionary<string, object?>
+                    {
+                        ["Id"] = song.ArtistId ?? song.Id,
+                        ["Name"] = song.Artist
+                    }
+                },
             ["IndexNumber"] = song.Track,
             ["ParentIndexNumber"] = song.DiscNumber ?? 1,
             ["ProductionYear"] = song.Year,
@@ -289,6 +297,24 @@ public class JellyfinResponseBuilder
                 var providerIds = (Dictionary<string, string>)item["ProviderIds"]!;
                 providerIds["ISRC"] = song.Isrc;
             }
+            
+            // Add MediaSources with bitrate for external tracks
+            item["MediaSources"] = new[]
+            {
+                new Dictionary<string, object?>
+                {
+                    ["Id"] = song.Id,
+                    ["Type"] = "Default",
+                    ["Container"] = "flac",
+                    ["Size"] = (song.Duration ?? 180) * 1337 * 128, // Approximate file size
+                    ["Bitrate"] = 1337000, // 1337 kbps in bps
+                    ["Path"] = $"/music/{song.Artist}/{song.Album}/{song.Title}.flac",
+                    ["Protocol"] = "File",
+                    ["SupportsDirectStream"] = true,
+                    ["SupportsTranscoding"] = true,
+                    ["SupportsDirectPlay"] = true
+                }
+            };
         }
 
         if (!string.IsNullOrEmpty(song.Genre))
@@ -304,11 +330,11 @@ public class JellyfinResponseBuilder
     /// </summary>
     public Dictionary<string, object?> ConvertAlbumToJellyfinItem(Album album)
     {
-        // Add " - SW" suffix to external album names
+        // Add " - S" suffix to external album names (S = SquidWTF)
         var albumName = album.Title;
         if (!album.IsLocal)
         {
-            albumName = $"{album.Title} - SW";
+            albumName = $"{album.Title} - S";
         }
         
         var item = new Dictionary<string, object?>
@@ -371,11 +397,11 @@ public class JellyfinResponseBuilder
     /// </summary>
     public Dictionary<string, object?> ConvertArtistToJellyfinItem(Artist artist)
     {
-        // Add " - SW" suffix to external artist names
+        // Add " - S" suffix to external artist names (S = SquidWTF)
         var artistName = artist.Name;
         if (!artist.IsLocal)
         {
-            artistName = $"{artist.Name} - SW";
+            artistName = $"{artist.Name} - S";
         }
         
         var item = new Dictionary<string, object?>

allstarr/Services/Jellyfin/JellyfinSessionManager.cs

@@ -0,0 +1,450 @@
+using System.Collections.Concurrent;
+using System.Net.WebSockets;
+using System.Text;
+using System.Text.Json;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Options;
+using allstarr.Models.Settings;
+
+namespace allstarr.Services.Jellyfin;
+
+/// <summary>
+/// Manages Jellyfin sessions for connected clients.
+/// Creates sessions on first playback and keeps them alive with periodic pings.
+/// Also maintains server-side WebSocket connections to Jellyfin on behalf of clients.
+/// </summary>
+public class JellyfinSessionManager : IDisposable
+{
+    private readonly JellyfinProxyService _proxyService;
+    private readonly JellyfinSettings _settings;
+    private readonly ILogger<JellyfinSessionManager> _logger;
+    private readonly ConcurrentDictionary<string, SessionInfo> _sessions = new();
+    private readonly Timer _keepAliveTimer;
+
+    public JellyfinSessionManager(
+        JellyfinProxyService proxyService,
+        IOptions<JellyfinSettings> settings,
+        ILogger<JellyfinSessionManager> logger)
+    {
+        _proxyService = proxyService;
+        _settings = settings.Value;
+        _logger = logger;
+
+        // Keep sessions alive every 10 seconds (Jellyfin considers sessions stale after ~15 seconds of inactivity)
+        _keepAliveTimer = new Timer(KeepSessionsAlive, null, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10));
+        
+        _logger.LogWarning("🔧 SESSION: JellyfinSessionManager initialized with 10-second keep-alive and WebSocket support");
+    }
+
+    /// <summary>
+    /// Ensures a session exists for the given device. Creates one if needed.
+    /// </summary>
+    public async Task<bool> EnsureSessionAsync(string deviceId, string client, string device, string version, IHeaderDictionary headers)
+    {
+        if (string.IsNullOrEmpty(deviceId))
+        {
+            _logger.LogWarning("⚠️ SESSION: Cannot create session - no device ID");
+            return false;
+        }
+
+        // Check if we already have this session tracked
+        if (_sessions.TryGetValue(deviceId, out var existingSession))
+        {
+            existingSession.LastActivity = DateTime.UtcNow;
+            _logger.LogWarning("✓ SESSION: Session already exists for device {DeviceId}", deviceId);
+            
+            // Refresh capabilities to keep session alive
+            await PostCapabilitiesAsync(headers);
+            return true;
+        }
+
+        _logger.LogWarning("🔧 SESSION: Creating new session for device: {DeviceId} ({Client} on {Device})", deviceId, client, device);
+        
+        // Log the headers we received for debugging
+        _logger.LogWarning("🔍 SESSION: Headers received for session creation: {Headers}", 
+            string.Join(", ", headers.Select(h => $"{h.Key}={h.Value.ToString().Substring(0, Math.Min(30, h.Value.ToString().Length))}...")));
+
+        try
+        {
+            // Post session capabilities to Jellyfin - this creates the session
+            await PostCapabilitiesAsync(headers);
+
+            _logger.LogWarning("✓ SESSION: Session created for {DeviceId}", deviceId);
+
+            // Track this session
+            _sessions[deviceId] = new SessionInfo
+            {
+                DeviceId = deviceId,
+                Client = client,
+                Device = device,
+                Version = version,
+                LastActivity = DateTime.UtcNow,
+                Headers = CloneHeaders(headers)
+            };
+
+            // Start a WebSocket connection to Jellyfin on behalf of this client
+            _ = Task.Run(() => MaintainWebSocketForSessionAsync(deviceId, headers));
+
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "❌ SESSION: Error creating session for {DeviceId}", deviceId);
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Posts session capabilities to Jellyfin.
+    /// </summary>
+    private async Task PostCapabilitiesAsync(IHeaderDictionary headers)
+    {
+        var capabilities = new
+        {
+            PlayableMediaTypes = new[] { "Audio" },
+            SupportedCommands = new[]
+            {
+                "Play",
+                "Playstate",
+                "PlayNext"
+            },
+            SupportsMediaControl = true,
+            SupportsPersistentIdentifier = true,
+            SupportsSync = false
+        };
+
+        var json = JsonSerializer.Serialize(capabilities);
+        var (result, statusCode) = await _proxyService.PostJsonAsync("Sessions/Capabilities/Full", json, headers);
+
+        if (statusCode == 204 || statusCode == 200)
+        {
+            _logger.LogWarning("✓ SESSION: Posted capabilities successfully ({StatusCode})", statusCode);
+        }
+        else
+        {
+            _logger.LogWarning("⚠️ SESSION: Failed to post capabilities - status {StatusCode}", statusCode);
+        }
+    }
+
+    /// <summary>
+    /// Updates session activity timestamp.
+    /// </summary>
+    public void UpdateActivity(string deviceId)
+    {
+        if (_sessions.TryGetValue(deviceId, out var session))
+        {
+            session.LastActivity = DateTime.UtcNow;
+            _logger.LogWarning("🔄 SESSION: Updated activity for {DeviceId}", deviceId);
+        }
+        else
+        {
+            _logger.LogWarning("⚠️ SESSION: Cannot update activity - device {DeviceId} not found", deviceId);
+        }
+    }
+
+    /// <summary>
+    /// Removes a session when the client disconnects.
+    /// </summary>
+    public async Task RemoveSessionAsync(string deviceId)
+    {
+        if (_sessions.TryRemove(deviceId, out var session))
+        {
+            _logger.LogWarning("🗑️ SESSION: Removing session for device {DeviceId}", deviceId);
+
+            // Close WebSocket if it exists
+            if (session.WebSocket != null && session.WebSocket.State == WebSocketState.Open)
+            {
+                try
+                {
+                    await session.WebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Session ended", CancellationToken.None);
+                    _logger.LogWarning("🔌 WEBSOCKET: Closed WebSocket for device {DeviceId}", deviceId);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "⚠️ WEBSOCKET: Error closing WebSocket for {DeviceId}", deviceId);
+                }
+                finally
+                {
+                    session.WebSocket?.Dispose();
+                }
+            }
+
+            try
+            {
+                // Optionally notify Jellyfin that the session is ending
+                // (Jellyfin will auto-cleanup inactive sessions anyway)
+                await _proxyService.PostJsonAsync("Sessions/Logout", "{}", session.Headers);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "⚠️ SESSION: Error removing session for {DeviceId}", deviceId);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Maintains a WebSocket connection to Jellyfin on behalf of a client session.
+    /// This allows the session to appear in Jellyfin's dashboard.
+    /// </summary>
+    private async Task MaintainWebSocketForSessionAsync(string deviceId, IHeaderDictionary headers)
+    {
+        if (!_sessions.TryGetValue(deviceId, out var session))
+        {
+            _logger.LogWarning("⚠️ WEBSOCKET: Cannot create WebSocket - session {DeviceId} not found", deviceId);
+            return;
+        }
+
+        ClientWebSocket? webSocket = null;
+
+        try
+        {
+            // Build Jellyfin WebSocket URL
+            var jellyfinUrl = _settings.Url?.TrimEnd('/') ?? "";
+            var wsScheme = jellyfinUrl.StartsWith("https://", StringComparison.OrdinalIgnoreCase) ? "wss://" : "ws://";
+            var jellyfinHost = jellyfinUrl.Replace("https://", "").Replace("http://", "");
+            var jellyfinWsUrl = $"{wsScheme}{jellyfinHost}/socket";
+
+            // IMPORTANT: Do NOT add api_key to URL - we want to authenticate as the CLIENT, not the server
+            // The client's token is passed via X-Emby-Authorization header
+            // Using api_key would create a session for the server/admin, not the actual user's client
+
+            webSocket = new ClientWebSocket();
+            session.WebSocket = webSocket;
+
+            // Log available headers for debugging
+            _logger.LogWarning("🔍 WEBSOCKET: Available headers for {DeviceId}: {Headers}", 
+                deviceId, string.Join(", ", headers.Keys));
+
+            // Forward authentication headers from the CLIENT - this is critical for session to appear under the right user
+            bool authFound = false;
+            if (headers.TryGetValue("X-Emby-Authorization", out var embyAuth))
+            {
+                webSocket.Options.SetRequestHeader("X-Emby-Authorization", embyAuth.ToString());
+                _logger.LogWarning("🔑 WEBSOCKET: Using X-Emby-Authorization for {DeviceId}: {Auth}", 
+                    deviceId, embyAuth.ToString().Length > 50 ? embyAuth.ToString()[..50] + "..." : embyAuth.ToString());
+                authFound = true;
+            }
+            else if (headers.TryGetValue("Authorization", out var auth))
+            {
+                var authValue = auth.ToString();
+                if (authValue.Contains("MediaBrowser", StringComparison.OrdinalIgnoreCase))
+                {
+                    webSocket.Options.SetRequestHeader("X-Emby-Authorization", authValue);
+                    _logger.LogWarning("🔑 WEBSOCKET: Converted Authorization to X-Emby-Authorization for {DeviceId}: {Auth}", 
+                        deviceId, authValue.Length > 50 ? authValue[..50] + "..." : authValue);
+                    authFound = true;
+                }
+                else
+                {
+                    webSocket.Options.SetRequestHeader("Authorization", authValue);
+                    _logger.LogWarning("🔑 WEBSOCKET: Using Authorization for {DeviceId}: {Auth}", 
+                        deviceId, authValue.Length > 50 ? authValue[..50] + "..." : authValue);
+                    authFound = true;
+                }
+            }
+            
+            if (!authFound)
+            {
+                // No client auth found - fall back to server API key as last resort
+                if (!string.IsNullOrEmpty(_settings.ApiKey))
+                {
+                    jellyfinWsUrl += $"?api_key={_settings.ApiKey}";
+                    _logger.LogWarning("⚠️ WEBSOCKET: No client auth found in headers, falling back to server API key for {DeviceId}", deviceId);
+                }
+                else
+                {
+                    _logger.LogWarning("❌ WEBSOCKET: No authentication available for {DeviceId}!", deviceId);
+                }
+            }
+
+            _logger.LogWarning("🔗 WEBSOCKET: Connecting to Jellyfin for device {DeviceId}: {Url}", deviceId, jellyfinWsUrl);
+
+            // Set user agent
+            webSocket.Options.SetRequestHeader("User-Agent", $"Allstarr-Proxy/{session.Client}");
+
+            // Connect to Jellyfin
+            await webSocket.ConnectAsync(new Uri(jellyfinWsUrl), CancellationToken.None);
+            _logger.LogWarning("✓ WEBSOCKET: Connected to Jellyfin for device {DeviceId}", deviceId);
+
+            // CRITICAL: Send ForceKeepAlive message to initialize session in Jellyfin
+            // This tells Jellyfin to create/show the session in the dashboard
+            // Without this message, the WebSocket is connected but no session appears
+            var forceKeepAliveMessage = "{\"MessageType\":\"ForceKeepAlive\",\"Data\":100}";
+            var messageBytes = Encoding.UTF8.GetBytes(forceKeepAliveMessage);
+            await webSocket.SendAsync(new ArraySegment<byte>(messageBytes), WebSocketMessageType.Text, true, CancellationToken.None);
+            _logger.LogWarning("📤 WEBSOCKET: Sent ForceKeepAlive to initialize session for {DeviceId}", deviceId);
+
+            // Also send SessionsStart to subscribe to session updates
+            var sessionsStartMessage = "{\"MessageType\":\"SessionsStart\",\"Data\":\"0,1500\"}";
+            messageBytes = Encoding.UTF8.GetBytes(sessionsStartMessage);
+            await webSocket.SendAsync(new ArraySegment<byte>(messageBytes), WebSocketMessageType.Text, true, CancellationToken.None);
+            _logger.LogWarning("📤 WEBSOCKET: Sent SessionsStart for {DeviceId}", deviceId);
+
+            // Keep the WebSocket alive by reading messages and sending periodic keep-alive
+            var buffer = new byte[1024 * 4];
+            var lastKeepAlive = DateTime.UtcNow;
+            using var cts = new CancellationTokenSource();
+            
+            while (webSocket.State == WebSocketState.Open && _sessions.ContainsKey(deviceId))
+            {
+                try
+                {
+                    // Use a timeout so we can send keep-alive messages periodically
+                    using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(cts.Token);
+                    timeoutCts.CancelAfter(TimeSpan.FromSeconds(30));
+                    
+                    try
+                    {
+                        var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), timeoutCts.Token);
+
+                        if (result.MessageType == WebSocketMessageType.Close)
+                        {
+                            _logger.LogWarning("🔌 WEBSOCKET: Jellyfin closed WebSocket for device {DeviceId}", deviceId);
+                            break;
+                        }
+
+                        // Log received messages for debugging
+                        if (result.MessageType == WebSocketMessageType.Text)
+                        {
+                            var message = Encoding.UTF8.GetString(buffer, 0, result.Count);
+                            _logger.LogWarning("📥 WEBSOCKET: Received from Jellyfin for {DeviceId}: {Message}", 
+                                deviceId, message.Length > 100 ? message[..100] + "..." : message);
+                                
+                            // Respond to KeepAlive requests from Jellyfin
+                            if (message.Contains("\"MessageType\":\"KeepAlive\""))
+                            {
+                                _logger.LogWarning("💓 WEBSOCKET: Received KeepAlive from Jellyfin for {DeviceId}", deviceId);
+                            }
+                        }
+                    }
+                    catch (OperationCanceledException) when (!cts.IsCancellationRequested)
+                    {
+                        // Timeout - this is expected, send keep-alive if needed
+                    }
+                    
+                    // Send periodic keep-alive every 30 seconds
+                    if (DateTime.UtcNow - lastKeepAlive > TimeSpan.FromSeconds(30))
+                    {
+                        var keepAliveMsg = "{\"MessageType\":\"KeepAlive\"}";
+                        var keepAliveBytes = Encoding.UTF8.GetBytes(keepAliveMsg);
+                        await webSocket.SendAsync(new ArraySegment<byte>(keepAliveBytes), WebSocketMessageType.Text, true, CancellationToken.None);
+                        _logger.LogWarning("💓 WEBSOCKET: Sent KeepAlive for {DeviceId}", deviceId);
+                        lastKeepAlive = DateTime.UtcNow;
+                    }
+                }
+                catch (WebSocketException wsEx)
+                {
+                    _logger.LogWarning(wsEx, "⚠️ WEBSOCKET: WebSocket error for device {DeviceId}", deviceId);
+                    break;
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "❌ WEBSOCKET: Failed to maintain WebSocket for device {DeviceId}", deviceId);
+        }
+        finally
+        {
+            if (webSocket != null)
+            {
+                if (webSocket.State == WebSocketState.Open)
+                {
+                    try
+                    {
+                        await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Session ended", CancellationToken.None);
+                    }
+                    catch { }
+                }
+                webSocket.Dispose();
+                _logger.LogWarning("🧹 WEBSOCKET: Cleaned up WebSocket for device {DeviceId}", deviceId);
+            }
+
+            // Clear WebSocket reference from session
+            if (_sessions.TryGetValue(deviceId, out var sess))
+            {
+                sess.WebSocket = null;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Periodically pings Jellyfin to keep sessions alive.
+    /// </summary>
+    private async void KeepSessionsAlive(object? state)
+    {
+        var now = DateTime.UtcNow;
+        var activeSessions = _sessions.Values.Where(s => now - s.LastActivity < TimeSpan.FromMinutes(5)).ToList();
+
+        if (activeSessions.Count == 0)
+        {
+            return;
+        }
+
+        _logger.LogWarning("💓 SESSION: Keeping {Count} sessions alive", activeSessions.Count);
+
+        foreach (var session in activeSessions)
+        {
+            try
+            {
+                // Post capabilities again to keep session alive
+                await PostCapabilitiesAsync(session.Headers);
+                _logger.LogWarning("✓ SESSION: Kept session alive for {DeviceId}", session.DeviceId);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "⚠️ SESSION: Error keeping session alive for {DeviceId}", session.DeviceId);
+            }
+        }
+
+        // Clean up stale sessions (inactive for > 10 minutes)
+        var staleSessions = _sessions.Where(kvp => now - kvp.Value.LastActivity > TimeSpan.FromMinutes(10)).ToList();
+        foreach (var stale in staleSessions)
+        {
+            _logger.LogWarning("🧹 SESSION: Removing stale session for {DeviceId}", stale.Key);
+            _sessions.TryRemove(stale.Key, out _);
+        }
+    }
+
+    private static IHeaderDictionary CloneHeaders(IHeaderDictionary headers)
+    {
+        var cloned = new HeaderDictionary();
+        foreach (var header in headers)
+        {
+            cloned[header.Key] = header.Value;
+        }
+        return cloned;
+    }
+
+    private class SessionInfo
+    {
+        public required string DeviceId { get; init; }
+        public required string Client { get; init; }
+        public required string Device { get; init; }
+        public required string Version { get; init; }
+        public DateTime LastActivity { get; set; }
+        public required IHeaderDictionary Headers { get; init; }
+        public ClientWebSocket? WebSocket { get; set; }
+    }
+
+    public void Dispose()
+    {
+        _keepAliveTimer?.Dispose();
+        
+        // Close all WebSocket connections
+        foreach (var session in _sessions.Values)
+        {
+            if (session.WebSocket != null && session.WebSocket.State == WebSocketState.Open)
+            {
+                try
+                {
+                    session.WebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Service stopping", CancellationToken.None).Wait(TimeSpan.FromSeconds(5));
+                }
+                catch { }
+                finally
+                {
+                    session.WebSocket?.Dispose();
+                }
+            }
+        }
+    }
+}

allstarr/Services/Lyrics/LrclibService.cs

@@ -25,6 +25,12 @@ public class LrclibService
 
     public async Task<LyricsInfo?> GetLyricsAsync(string trackName, string artistName, string albumName, int durationSeconds)
     {
+        return await GetLyricsAsync(trackName, new[] { artistName }, albumName, durationSeconds);
+    }
+
+    public async Task<LyricsInfo?> GetLyricsAsync(string trackName, string[] artistNames, string albumName, int durationSeconds)
+    {
+        var artistName = string.Join(", ", artistNames);
         var cacheKey = $"lyrics:{artistName}:{trackName}:{albumName}:{durationSeconds}";
         
         var cached = await _cache.GetStringAsync(cacheKey);
@@ -42,25 +48,112 @@ public class LrclibService
 
         try
         {
-            var url = $"{BaseUrl}/get?" +
-                     $"track_name={Uri.EscapeDataString(trackName)}&" +
-                     $"artist_name={Uri.EscapeDataString(artistName)}&" +
-                     $"album_name={Uri.EscapeDataString(albumName)}&" +
-                     $"duration={durationSeconds}";
-
-            _logger.LogDebug("Fetching lyrics from LRCLIB: {Url}", url);
-
-            var response = await _httpClient.GetAsync(url);
+            // Try searching with all artists joined (space-separated for better matching)
+            var searchArtistName = string.Join(" ", artistNames);
             
-            if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
+            // First try search API for fuzzy matching (more forgiving)
+            var searchUrl = $"{BaseUrl}/search?" +
+                           $"track_name={Uri.EscapeDataString(trackName)}&" +
+                           $"artist_name={Uri.EscapeDataString(searchArtistName)}";
+
+            _logger.LogInformation("Searching LRCLIB: {Url} (expecting {ArtistCount} artists)", searchUrl, artistNames.Length);
+
+            var searchResponse = await _httpClient.GetAsync(searchUrl);
+            
+            if (searchResponse.IsSuccessStatusCode)
+            {
+                var searchJson = await searchResponse.Content.ReadAsStringAsync();
+                var searchResults = JsonSerializer.Deserialize<List<LrclibResponse>>(searchJson, JsonOptions);
+
+                if (searchResults != null && searchResults.Count > 0)
+                {
+                    // Find best match by comparing track name, artist, and duration
+                    LrclibResponse? bestMatch = null;
+                    double bestScore = 0;
+
+                    foreach (var result in searchResults)
+                    {
+                        // Calculate similarity scores
+                        var trackScore = CalculateSimilarity(trackName, result.TrackName ?? "");
+                        
+                        // Count artists in the result
+                        var resultArtistCount = CountArtists(result.ArtistName ?? "");
+                        var expectedArtistCount = artistNames.Length;
+                        
+                        // Artist matching - check if all our artists are present
+                        var artistScore = CalculateArtistSimilarity(artistNames, result.ArtistName ?? "");
+                        
+                        // STRONG bonus for matching artist count (this is critical!)
+                        var artistCountBonus = resultArtistCount == expectedArtistCount ? 50.0 : 0.0;
+                        
+                        // Duration match (within 5 seconds is good)
+                        var durationDiff = Math.Abs(result.Duration - durationSeconds);
+                        var durationScore = durationDiff <= 5 ? 100.0 : Math.Max(0, 100 - (durationDiff * 2));
+                        
+                        // Bonus for having synced lyrics (prefer synced over plain)
+                        var syncedBonus = !string.IsNullOrEmpty(result.SyncedLyrics) ? 15.0 : 0.0;
+                        
+                        // Weighted score: track name important, artist match critical, artist count VERY important
+                        var totalScore = (trackScore * 0.3) + (artistScore * 0.3) + (durationScore * 0.15) + artistCountBonus + syncedBonus;
+                        
+                        _logger.LogDebug("Candidate: {Track} by {Artist} ({ArtistCount} artists) - Score: {Score:F1} (track:{TrackScore:F1}, artist:{ArtistScore:F1}, duration:{DurationScore:F1}, countBonus:{CountBonus:F1}, synced:{Synced})",
+                            result.TrackName, result.ArtistName, resultArtistCount, totalScore, trackScore, artistScore, durationScore, artistCountBonus, !string.IsNullOrEmpty(result.SyncedLyrics));
+
+                        if (totalScore > bestScore)
+                        {
+                            bestScore = totalScore;
+                            bestMatch = result;
+                        }
+                    }
+
+                    // Only use result if score is good enough (>60%)
+                    if (bestMatch != null && bestScore >= 60)
+                    {
+                        _logger.LogInformation("✓ Found lyrics via search for {Artist} - {Track} (ID: {Id}, score: {Score:F1}, synced: {HasSynced})", 
+                            artistName, trackName, bestMatch.Id, bestScore, !string.IsNullOrEmpty(bestMatch.SyncedLyrics));
+
+                        var result = new LyricsInfo
+                        {
+                            Id = bestMatch.Id,
+                            TrackName = bestMatch.TrackName ?? trackName,
+                            ArtistName = bestMatch.ArtistName ?? artistName,
+                            AlbumName = bestMatch.AlbumName ?? albumName,
+                            Duration = (int)Math.Round(bestMatch.Duration),
+                            Instrumental = bestMatch.Instrumental,
+                            PlainLyrics = bestMatch.PlainLyrics,
+                            SyncedLyrics = bestMatch.SyncedLyrics
+                        };
+
+                        await _cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(result, JsonOptions), TimeSpan.FromDays(30));
+                        return result;
+                    }
+                    else
+                    {
+                        _logger.LogInformation("Best match score too low ({Score:F1}), trying exact match", bestScore);
+                    }
+                }
+            }
+
+            // Fall back to exact match API if search didn't find good results
+            var exactUrl = $"{BaseUrl}/get?" +
+                          $"track_name={Uri.EscapeDataString(trackName)}&" +
+                          $"artist_name={Uri.EscapeDataString(artistName)}&" +
+                          $"album_name={Uri.EscapeDataString(albumName)}&" +
+                          $"duration={durationSeconds}";
+
+            _logger.LogDebug("Trying exact match from LRCLIB: {Url}", exactUrl);
+
+            var exactResponse = await _httpClient.GetAsync(exactUrl);
+            
+            if (exactResponse.StatusCode == System.Net.HttpStatusCode.NotFound)
             {
                 _logger.LogDebug("Lyrics not found for {Artist} - {Track}", artistName, trackName);
                 return null;
             }
 
-            response.EnsureSuccessStatusCode();
+            exactResponse.EnsureSuccessStatusCode();
             
-            var json = await response.Content.ReadAsStringAsync();
+            var json = await exactResponse.Content.ReadAsStringAsync();
             var lyrics = JsonSerializer.Deserialize<LrclibResponse>(json, JsonOptions);
 
             if (lyrics == null)
@@ -68,7 +161,7 @@ public class LrclibService
                 return null;
             }
 
-            var result = new LyricsInfo
+            var exactResult = new LyricsInfo
             {
                 Id = lyrics.Id,
                 TrackName = lyrics.TrackName ?? trackName,
@@ -80,11 +173,11 @@ public class LrclibService
                 SyncedLyrics = lyrics.SyncedLyrics
             };
 
-            await _cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(result, JsonOptions), TimeSpan.FromDays(30));
+            await _cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(exactResult, JsonOptions), TimeSpan.FromDays(30));
 
-            _logger.LogInformation("Retrieved lyrics for {Artist} - {Track} (ID: {Id})", artistName, trackName, lyrics.Id);
+            _logger.LogInformation("Retrieved lyrics via exact match for {Artist} - {Track} (ID: {Id})", artistName, trackName, lyrics.Id);
             
-            return result;
+            return exactResult;
         }
         catch (HttpRequestException ex)
         {
@@ -98,6 +191,91 @@ public class LrclibService
         }
     }
 
+    /// <summary>
+    /// Counts the number of artists in an artist string (separated by comma, ampersand, or 'e')
+    /// </summary>
+    private static int CountArtists(string artistString)
+    {
+        if (string.IsNullOrWhiteSpace(artistString))
+            return 0;
+        
+        // Split by common separators: comma, ampersand, " e " (Portuguese/Spanish "and")
+        var separators = new[] { ',', '&' };
+        var parts = artistString.Split(separators, StringSplitOptions.RemoveEmptyEntries);
+        
+        // Also check for " e " pattern (like "Julia Michaels e Alessia Cara")
+        var count = parts.Length;
+        foreach (var part in parts)
+        {
+            if (part.Contains(" e ", StringComparison.OrdinalIgnoreCase))
+            {
+                count += part.Split(new[] { " e " }, StringSplitOptions.RemoveEmptyEntries).Length - 1;
+            }
+        }
+        
+        return Math.Max(1, count);
+    }
+
+    /// <summary>
+    /// Calculates how well the expected artists match the result's artist string
+    /// </summary>
+    private static double CalculateArtistSimilarity(string[] expectedArtists, string resultArtistString)
+    {
+        if (expectedArtists.Length == 0 || string.IsNullOrWhiteSpace(resultArtistString))
+            return 0;
+        
+        var resultLower = resultArtistString.ToLowerInvariant();
+        var matchedCount = 0;
+        
+        foreach (var artist in expectedArtists)
+        {
+            var artistLower = artist.ToLowerInvariant();
+            
+            // Check if this artist appears in the result string
+            if (resultLower.Contains(artistLower))
+            {
+                matchedCount++;
+            }
+            else
+            {
+                // Try token-based matching for partial matches
+                var artistTokens = artistLower.Split(new[] { ' ', '-', '_' }, StringSplitOptions.RemoveEmptyEntries);
+                var matchedTokens = artistTokens.Count(token => resultLower.Contains(token));
+                
+                // If most tokens match, count it as a partial match
+                if (matchedTokens >= artistTokens.Length * 0.7)
+                {
+                    matchedCount++;
+                }
+            }
+        }
+        
+        // Return percentage of artists matched
+        return (matchedCount * 100.0) / expectedArtists.Length;
+    }
+
+    private static double CalculateSimilarity(string str1, string str2)
+    {
+        if (string.IsNullOrEmpty(str1) || string.IsNullOrEmpty(str2))
+            return 0;
+
+        str1 = str1.ToLowerInvariant();
+        str2 = str2.ToLowerInvariant();
+
+        if (str1 == str2)
+            return 100;
+
+        // Simple token-based matching
+        var tokens1 = str1.Split(new[] { ' ', '-', '_' }, StringSplitOptions.RemoveEmptyEntries);
+        var tokens2 = str2.Split(new[] { ' ', '-', '_' }, StringSplitOptions.RemoveEmptyEntries);
+
+        if (tokens1.Length == 0 || tokens2.Length == 0)
+            return 0;
+
+        var matchedTokens = tokens1.Count(t1 => tokens2.Any(t2 => t2.Contains(t1) || t1.Contains(t2)));
+        return (matchedTokens * 100.0) / Math.Max(tokens1.Length, tokens2.Length);
+    }
+
     public async Task<LyricsInfo?> GetLyricsCachedAsync(string trackName, string artistName, string albumName, int durationSeconds)
     {
         try

allstarr/Services/Spotify/SpotifyMissingTracksFetcher.cs

@@ -0,0 +1,660 @@
+using allstarr.Models.Settings;
+using allstarr.Models.Spotify;
+using allstarr.Services.Common;
+using allstarr.Services.Jellyfin;
+using Microsoft.Extensions.Options;
+using System.Text.Json;
+
+namespace allstarr.Services.Spotify;
+
+public class SpotifyMissingTracksFetcher : BackgroundService
+{
+    private readonly IOptions<SpotifyImportSettings> _spotifySettings;
+    private readonly IOptions<JellyfinSettings> _jellyfinSettings;
+    private readonly IHttpClientFactory _httpClientFactory;
+    private readonly RedisCacheService _cache;
+    private readonly ILogger<SpotifyMissingTracksFetcher> _logger;
+    private readonly IServiceProvider _serviceProvider;
+    private bool _hasRunOnce = false;
+    private Dictionary<string, string> _playlistIdToName = new();
+    private const string CacheDirectory = "/app/cache/spotify";
+
+    public SpotifyMissingTracksFetcher(
+        IOptions<SpotifyImportSettings> spotifySettings,
+        IOptions<JellyfinSettings> jellyfinSettings,
+        IHttpClientFactory httpClientFactory,
+        RedisCacheService cache,
+        IServiceProvider serviceProvider,
+        ILogger<SpotifyMissingTracksFetcher> logger)
+    {
+        _spotifySettings = spotifySettings;
+        _jellyfinSettings = jellyfinSettings;
+        _httpClientFactory = httpClientFactory;
+        _cache = cache;
+        _serviceProvider = serviceProvider;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Public method to trigger fetching manually (called from controller).
+    /// </summary>
+    public async Task TriggerFetchAsync()
+    {
+        _logger.LogInformation("Manual fetch triggered");
+        await FetchMissingTracksAsync(CancellationToken.None, bypassSyncWindowCheck: true);
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        _logger.LogInformation("========================================");
+        _logger.LogInformation("SpotifyMissingTracksFetcher: Starting up...");
+        
+        // Ensure cache directory exists
+        Directory.CreateDirectory(CacheDirectory);
+        
+        if (!_spotifySettings.Value.Enabled)
+        {
+            _logger.LogInformation("Spotify playlist injection is DISABLED");
+            _logger.LogInformation("========================================");
+            return;
+        }
+
+        var jellyfinUrl = _jellyfinSettings.Value.Url;
+        var apiKey = _jellyfinSettings.Value.ApiKey;
+
+        if (string.IsNullOrEmpty(jellyfinUrl) || string.IsNullOrEmpty(apiKey))
+        {
+            _logger.LogWarning("Jellyfin URL or API key not configured, Spotify playlist injection disabled");
+            _logger.LogInformation("========================================");
+            return;
+        }
+
+        _logger.LogInformation("Spotify Import ENABLED");
+        _logger.LogInformation("Configured Playlists: {Count}", _spotifySettings.Value.Playlists.Count);
+        
+        // Log the search schedule
+        var settings = _spotifySettings.Value;
+        var syncTime = DateTime.Today
+            .AddHours(settings.SyncStartHour)
+            .AddMinutes(settings.SyncStartMinute);
+        var syncEndTime = syncTime.AddHours(settings.SyncWindowHours);
+        
+        _logger.LogInformation("Search Schedule:");
+        _logger.LogInformation("  Plugin sync time: {Time:HH:mm} UTC (configured)", syncTime);
+        _logger.LogInformation("  Search window: {Start:HH:mm} - {End:HH:mm} UTC ({Hours}h window)", 
+            syncTime, syncEndTime, settings.SyncWindowHours);
+        _logger.LogInformation("  Will search for new files once per day after sync window ends");
+        _logger.LogInformation("  Background check interval: 5 minutes");
+        
+        // Fetch playlist names from Jellyfin
+        await LoadPlaylistNamesAsync();
+        
+        _logger.LogInformation("Configured Playlists:");
+        foreach (var kvp in _playlistIdToName)
+        {
+            _logger.LogInformation("  - {Name} (ID: {Id})", kvp.Value, kvp.Key);
+        }
+        _logger.LogInformation("========================================");
+
+        // Check if we should run on startup
+        if (!_hasRunOnce)
+        {
+            var shouldRun = await ShouldRunOnStartupAsync();
+            if (shouldRun)
+            {
+                _logger.LogInformation("Running initial fetch on startup");
+                try
+                {
+                    await FetchMissingTracksAsync(stoppingToken, bypassSyncWindowCheck: true);
+                    _hasRunOnce = true;
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error during startup fetch");
+                }
+            }
+            else
+            {
+                _logger.LogInformation("Skipping startup fetch - already have current files");
+                _hasRunOnce = true;
+            }
+        }
+
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            try
+            {
+                // Only fetch if we're past today's sync window AND we haven't fetched today yet
+                var shouldFetch = await ShouldFetchNowAsync();
+                if (shouldFetch)
+                {
+                    await FetchMissingTracksAsync(stoppingToken);
+                    _hasRunOnce = true;
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error fetching Spotify missing tracks");
+            }
+
+            await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
+        }
+    }
+
+    private async Task<bool> ShouldFetchNowAsync()
+    {
+        var settings = _spotifySettings.Value;
+        var now = DateTime.UtcNow;
+        
+        // Calculate today's sync window
+        var todaySync = now.Date
+            .AddHours(settings.SyncStartHour)
+            .AddMinutes(settings.SyncStartMinute);
+        var todaySyncEnd = todaySync.AddHours(settings.SyncWindowHours);
+        
+        // Only fetch if we're past today's sync window
+        if (now < todaySyncEnd)
+        {
+            return false;
+        }
+        
+        // Check if we already have today's files
+        foreach (var playlistName in _playlistIdToName.Values)
+        {
+            var filePath = GetCacheFilePath(playlistName);
+            
+            if (File.Exists(filePath))
+            {
+                var fileTime = File.GetLastWriteTimeUtc(filePath);
+                
+                // If file is from today's sync or later, we already have it
+                if (fileTime >= todaySync)
+                {
+                    continue;
+                }
+            }
+            
+            // Missing today's file for this playlist
+            return true;
+        }
+        
+        // All playlists have today's files
+        return false;
+    }
+
+    private async Task LoadPlaylistNamesAsync()
+    {
+        _playlistIdToName.Clear();
+        
+        // Use configured playlists
+        foreach (var playlist in _spotifySettings.Value.Playlists)
+        {
+            _playlistIdToName[playlist.Id] = playlist.Name;
+        }
+    }
+
+    private async Task<bool> ShouldRunOnStartupAsync()
+    {
+        _logger.LogInformation("=== STARTUP CACHE CHECK ===");
+        
+        var settings = _spotifySettings.Value;
+        var now = DateTime.UtcNow;
+        
+        // Calculate today's sync window
+        var todaySync = now.Date
+            .AddHours(settings.SyncStartHour)
+            .AddMinutes(settings.SyncStartMinute);
+        var todaySyncEnd = todaySync.AddHours(settings.SyncWindowHours);
+        
+        _logger.LogInformation("Today's sync window: {Start:yyyy-MM-dd HH:mm} - {End:yyyy-MM-dd HH:mm} UTC", 
+            todaySync, todaySyncEnd);
+        _logger.LogInformation("Current time: {Now:yyyy-MM-dd HH:mm} UTC", now);
+        
+        // If we're still before today's sync window end, we should have yesterday's or today's file
+        // Don't search again until after today's sync window ends
+        if (now < todaySyncEnd)
+        {
+            _logger.LogInformation("We're before today's sync window end - checking if we have recent cache...");
+            
+            var allPlaylistsHaveCache = true;
+            
+            foreach (var playlistName in _playlistIdToName.Values)
+            {
+                var filePath = GetCacheFilePath(playlistName);
+                var cacheKey = $"spotify:missing:{playlistName}";
+                
+                // Check file cache
+                if (File.Exists(filePath))
+                {
+                    var fileAge = DateTime.UtcNow - File.GetLastWriteTimeUtc(filePath);
+                    _logger.LogInformation("  {Playlist}: Found file cache (age: {Age:F1}h)", playlistName, fileAge.TotalHours);
+                    
+                    // Load into Redis if not already there
+                    if (!await _cache.ExistsAsync(cacheKey))
+                    {
+                        await LoadFromFileCache(playlistName);
+                    }
+                    continue;
+                }
+                
+                // Check Redis cache
+                if (await _cache.ExistsAsync(cacheKey))
+                {
+                    _logger.LogInformation("  {Playlist}: Found in Redis cache", playlistName);
+                    continue;
+                }
+                
+                // No cache found for this playlist
+                _logger.LogInformation("  {Playlist}: No cache found", playlistName);
+                allPlaylistsHaveCache = false;
+            }
+            
+            if (allPlaylistsHaveCache)
+            {
+                _logger.LogInformation("=== ALL PLAYLISTS HAVE CACHE - SKIPPING STARTUP FETCH ===");
+                _logger.LogInformation("Will search again after {Time:yyyy-MM-dd HH:mm} UTC", todaySyncEnd);
+                return false;
+            }
+        }
+        
+        // If we're after today's sync window end, check if we already have today's file
+        if (now >= todaySyncEnd)
+        {
+            _logger.LogInformation("We're after today's sync window end - checking if we already fetched today's files...");
+            
+            var allPlaylistsHaveTodaysFile = true;
+            
+            foreach (var playlistName in _playlistIdToName.Values)
+            {
+                var filePath = GetCacheFilePath(playlistName);
+                var cacheKey = $"spotify:missing:{playlistName}";
+                
+                // Check if file exists and was created today (after sync start)
+                if (File.Exists(filePath))
+                {
+                    var fileTime = File.GetLastWriteTimeUtc(filePath);
+                    
+                    // File should be from today's sync window or later
+                    if (fileTime >= todaySync)
+                    {
+                        var fileAge = DateTime.UtcNow - fileTime;
+                        _logger.LogInformation("  {Playlist}: Have today's file (created {Time:yyyy-MM-dd HH:mm}, age: {Age:F1}h)", 
+                            playlistName, fileTime, fileAge.TotalHours);
+                        
+                        // Load into Redis if not already there
+                        if (!await _cache.ExistsAsync(cacheKey))
+                        {
+                            await LoadFromFileCache(playlistName);
+                        }
+                        continue;
+                    }
+                    else
+                    {
+                        _logger.LogInformation("  {Playlist}: File is old (from {Time:yyyy-MM-dd HH:mm}, before today's sync)", 
+                            playlistName, fileTime);
+                    }
+                }
+                else
+                {
+                    _logger.LogInformation("  {Playlist}: No file found", playlistName);
+                }
+                
+                allPlaylistsHaveTodaysFile = false;
+            }
+            
+            if (allPlaylistsHaveTodaysFile)
+            {
+                _logger.LogInformation("=== ALL PLAYLISTS HAVE TODAY'S FILES - SKIPPING STARTUP FETCH ===");
+                
+                // Calculate when to search next (tomorrow after sync window)
+                var tomorrowSyncEnd = todaySyncEnd.AddDays(1);
+                _logger.LogInformation("Will search again after {Time:yyyy-MM-dd HH:mm} UTC", tomorrowSyncEnd);
+                return false;
+            }
+        }
+        
+        _logger.LogInformation("=== WILL FETCH ON STARTUP ===");
+        return true;
+    }
+    
+    private string GetCacheFilePath(string playlistName)
+    {
+        var safeName = string.Join("_", playlistName.Split(Path.GetInvalidFileNameChars()));
+        return Path.Combine(CacheDirectory, $"{safeName}_missing.json");
+    }
+    
+    private async Task LoadFromFileCache(string playlistName)
+    {
+        try
+        {
+            var filePath = GetCacheFilePath(playlistName);
+            if (!File.Exists(filePath))
+                return;
+            
+            var json = await File.ReadAllTextAsync(filePath);
+            var tracks = JsonSerializer.Deserialize<List<MissingTrack>>(json);
+            
+            if (tracks != null && tracks.Count > 0)
+            {
+                var cacheKey = $"spotify:missing:{playlistName}";
+                var fileAge = DateTime.UtcNow - File.GetLastWriteTimeUtc(filePath);
+                
+                // No expiration - cache persists until next Jellyfin job generates new file
+                await _cache.SetAsync(cacheKey, tracks, TimeSpan.FromDays(365));
+                _logger.LogInformation("Loaded {Count} tracks from file cache for {Playlist} (age: {Age:F1}h, no expiration)", 
+                    tracks.Count, playlistName, fileAge.TotalHours);
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to load file cache for {Playlist}", playlistName);
+        }
+    }
+    
+    private async Task SaveToFileCache(string playlistName, List<MissingTrack> tracks)
+    {
+        try
+        {
+            var filePath = GetCacheFilePath(playlistName);
+            var json = JsonSerializer.Serialize(tracks, new JsonSerializerOptions { WriteIndented = true });
+            await File.WriteAllTextAsync(filePath, json);
+            _logger.LogInformation("Saved {Count} tracks to file cache for {Playlist}", 
+                tracks.Count, playlistName);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to save file cache for {Playlist}", playlistName);
+        }
+    }
+
+    private async Task FetchMissingTracksAsync(CancellationToken cancellationToken, bool bypassSyncWindowCheck = false)
+    {
+        var settings = _spotifySettings.Value;
+        var now = DateTime.UtcNow;
+        var syncStart = now.Date
+            .AddHours(settings.SyncStartHour)
+            .AddMinutes(settings.SyncStartMinute);
+        var syncEnd = syncStart.AddHours(settings.SyncWindowHours);
+
+        // Only run after the sync window has passed (unless bypassing for startup)
+        if (!bypassSyncWindowCheck && now < syncEnd)
+        {
+            _logger.LogInformation("Skipping fetch - sync window not passed yet (now: {Now}, window ends: {End})", 
+                now, syncEnd);
+            return;
+        }
+
+        if (bypassSyncWindowCheck)
+        {
+            _logger.LogInformation("=== FETCHING MISSING TRACKS (STARTUP MODE) ===");
+        }
+        else
+        {
+            _logger.LogInformation("=== FETCHING MISSING TRACKS (SYNC WINDOW PASSED) ===");
+        }
+
+        _logger.LogInformation("Processing {Count} playlists", _playlistIdToName.Count);
+        
+        // Track when we find files to optimize search for other playlists
+        DateTime? firstFoundTime = null;
+        var foundPlaylists = new HashSet<string>();
+        
+        foreach (var kvp in _playlistIdToName)
+        {
+            _logger.LogInformation("Fetching playlist: {Name}", kvp.Value);
+            var foundTime = await FetchPlaylistMissingTracksAsync(kvp.Value, cancellationToken, firstFoundTime);
+            
+            if (foundTime.HasValue)
+            {
+                foundPlaylists.Add(kvp.Value);
+                if (!firstFoundTime.HasValue)
+                {
+                    firstFoundTime = foundTime;
+                    _logger.LogInformation("  → Will search within ±1h of {Time:yyyy-MM-dd HH:mm} for remaining playlists", firstFoundTime.Value);
+                }
+            }
+        }
+        
+        _logger.LogInformation("=== FINISHED FETCHING MISSING TRACKS ({Found}/{Total} playlists found) ===", 
+            foundPlaylists.Count, _playlistIdToName.Count);
+    }
+
+    private async Task<DateTime?> FetchPlaylistMissingTracksAsync(
+        string playlistName,
+        CancellationToken cancellationToken,
+        DateTime? hintTime = null)
+    {
+        var cacheKey = $"spotify:missing:{playlistName}";
+        
+        // Check if we have existing cache
+        var existingTracks = await _cache.GetAsync<List<MissingTrack>>(cacheKey);
+        var filePath = GetCacheFilePath(playlistName);
+        
+        if (File.Exists(filePath))
+        {
+            var fileAge = DateTime.UtcNow - File.GetLastWriteTimeUtc(filePath);
+            _logger.LogInformation("  Existing cache file age: {Age:F1}h", fileAge.TotalHours);
+        }
+        
+        if (existingTracks != null && existingTracks.Count > 0)
+        {
+            _logger.LogInformation("  Current cache has {Count} tracks, will search for newer file", existingTracks.Count);
+        }
+        else
+        {
+            _logger.LogInformation("  No existing cache, will search for missing tracks file");
+        }
+        
+        var settings = _spotifySettings.Value;
+        var jellyfinUrl = _jellyfinSettings.Value.Url;
+        var apiKey = _jellyfinSettings.Value.ApiKey;
+        
+        if (string.IsNullOrEmpty(jellyfinUrl) || string.IsNullOrEmpty(apiKey))
+        {
+            _logger.LogWarning("  Jellyfin URL or API key not configured, skipping fetch");
+            return null;
+        }
+        
+        var httpClient = _httpClientFactory.CreateClient();
+        
+        // Search starting from 24 hours ahead, going backwards for 72 hours
+        // This handles timezone differences where the plugin may have run "in the future" from our perspective
+        var now = DateTime.UtcNow;
+        var searchStart = now.AddHours(24); // Start 24 hours from now
+        var totalMinutesToSearch = 72 * 60; // 72 hours = 4320 minutes
+        
+        _logger.LogInformation("  Current UTC time: {Now:yyyy-MM-dd HH:mm}", now);
+        _logger.LogInformation("  Search start: {Start:yyyy-MM-dd HH:mm} (24h ahead)", searchStart);
+        _logger.LogInformation("  Searching backwards for 72 hours ({Minutes} minutes)", totalMinutesToSearch);
+
+        var found = false;
+        DateTime? foundFileTime = null;
+        
+        // If we have a hint time from another playlist, search ±1 hour around it first
+        if (hintTime.HasValue)
+        {
+            _logger.LogInformation("  Hint: Searching ±1h around {Time:yyyy-MM-dd HH:mm} (from another playlist)", hintTime.Value);
+            
+            // Search ±60 minutes around the hint time
+            for (var minuteOffset = 0; minuteOffset <= 60; minuteOffset++)
+            {
+                if (cancellationToken.IsCancellationRequested) break;
+
+                // Try both forward and backward from hint
+                if (minuteOffset > 0)
+                {
+                    // Try forward
+                    var timeForward = hintTime.Value.AddMinutes(minuteOffset);
+                    var resultForward = await TryFetchMissingTracksFile(playlistName, timeForward, jellyfinUrl, apiKey, httpClient, cancellationToken);
+                    if (resultForward.found)
+                    {
+                        found = true;
+                        foundFileTime = resultForward.fileTime;
+                        _logger.LogInformation("  ✓ Found using hint (+{Minutes}min from hint)", minuteOffset);
+                        return foundFileTime;
+                    }
+                }
+                
+                // Try backward
+                var timeBackward = hintTime.Value.AddMinutes(-minuteOffset);
+                var resultBackward = await TryFetchMissingTracksFile(playlistName, timeBackward, jellyfinUrl, apiKey, httpClient, cancellationToken);
+                if (resultBackward.found)
+                {
+                    found = true;
+                    foundFileTime = resultBackward.fileTime;
+                    _logger.LogInformation("  ✓ Found using hint (-{Minutes}min from hint)", minuteOffset);
+                    return foundFileTime;
+                }
+            }
+            
+            _logger.LogInformation("  Not found within ±1h of hint, doing full search...");
+        }
+        
+        // Search from 24h ahead, going backwards minute by minute for 72 hours
+        _logger.LogInformation("  Searching from {Start:yyyy-MM-dd HH:mm} backwards to {End:yyyy-MM-dd HH:mm}...", 
+            searchStart, searchStart.AddMinutes(-totalMinutesToSearch));
+        
+        for (var minutesBehind = 0; minutesBehind <= totalMinutesToSearch; minutesBehind++)
+        {
+            if (cancellationToken.IsCancellationRequested) break;
+
+            var time = searchStart.AddMinutes(-minutesBehind);
+            
+            var result = await TryFetchMissingTracksFile(playlistName, time, jellyfinUrl, apiKey, httpClient, cancellationToken);
+            if (result.found)
+            {
+                found = true;
+                foundFileTime = result.fileTime;
+                return foundFileTime;
+            }
+            
+            // Small delay every 60 requests to avoid rate limiting
+            if (minutesBehind > 0 && minutesBehind % 60 == 0)
+            {
+                await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken);
+            }
+        }
+        
+        if (!found)
+        {
+            _logger.LogWarning("  ✗ Could not find new missing tracks file (searched +24h forward, -48h backward)");
+            
+            // Keep the existing cache - don't let it expire
+            if (existingTracks != null && existingTracks.Count > 0)
+            {
+                _logger.LogInformation("  ✓ Keeping existing cache with {Count} tracks (no expiration)", existingTracks.Count);
+                // Re-save with no expiration to ensure it persists
+                await _cache.SetAsync(cacheKey, existingTracks, TimeSpan.FromDays(365)); // Effectively no expiration
+            }
+            else if (File.Exists(filePath))
+            {
+                // Load from file if Redis cache is empty
+                _logger.LogInformation("  📦 Loading existing file cache to keep playlist populated");
+                try
+                {
+                    var json = await File.ReadAllTextAsync(filePath, cancellationToken);
+                    var tracks = JsonSerializer.Deserialize<List<MissingTrack>>(json);
+                    
+                    if (tracks != null && tracks.Count > 0)
+                    {
+                        await _cache.SetAsync(cacheKey, tracks, TimeSpan.FromDays(365)); // No expiration
+                        _logger.LogInformation("  ✓ Loaded {Count} tracks from file cache (no expiration)", tracks.Count);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "  Failed to reload cache from file for {Playlist}", playlistName);
+                }
+            }
+            else
+            {
+                _logger.LogWarning("  No existing cache to keep - playlist will be empty until tracks are found");
+            }
+        }
+        
+        return foundFileTime;
+    }
+
+    private async Task<(bool found, DateTime? fileTime)> TryFetchMissingTracksFile(
+        string playlistName,
+        DateTime time,
+        string jellyfinUrl,
+        string apiKey,
+        HttpClient httpClient,
+        CancellationToken cancellationToken)
+    {
+        var filename = $"{playlistName}_missing_{time:yyyy-MM-dd_HH-mm}.json";
+        var url = $"{jellyfinUrl}/Viperinius.Plugin.SpotifyImport/MissingTracksFile" +
+                 $"?name={Uri.EscapeDataString(filename)}&api_key={apiKey}";
+
+        try
+        {
+            // Log every request with the actual filename
+            _logger.LogInformation("Checking: {Playlist} at {DateTime}", playlistName, time.ToString("yyyy-MM-dd HH:mm"));
+            
+            var response = await httpClient.GetAsync(url, cancellationToken);
+            if (response.IsSuccessStatusCode)
+            {
+                var json = await response.Content.ReadAsStringAsync(cancellationToken);
+                var tracks = ParseMissingTracks(json);
+                
+                if (tracks.Count > 0)
+                {
+                    var cacheKey = $"spotify:missing:{playlistName}";
+                    
+                    // Save to both Redis and file with extended TTL until next job runs
+                    // Set to 365 days (effectively no expiration) - will be replaced when Jellyfin generates new file
+                    await _cache.SetAsync(cacheKey, tracks, TimeSpan.FromDays(365));
+                    await SaveToFileCache(playlistName, tracks);
+                    
+                    _logger.LogInformation(
+                        "✓ FOUND! Cached {Count} missing tracks for {Playlist} from {Filename}",
+                        tracks.Count, playlistName, filename);
+                    return (true, time);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to fetch {Filename}", filename);
+        }
+        
+        return (false, null);
+    }
+
+    private List<MissingTrack> ParseMissingTracks(string json)
+    {
+        var tracks = new List<MissingTrack>();
+        
+        try
+        {
+            var doc = JsonDocument.Parse(json);
+            
+            foreach (var item in doc.RootElement.EnumerateArray())
+            {
+                var track = new MissingTrack
+                {
+                    SpotifyId = item.GetProperty("Id").GetString() ?? "",
+                    Title = item.GetProperty("Name").GetString() ?? "",
+                    Album = item.GetProperty("AlbumName").GetString() ?? "",
+                    Artists = item.GetProperty("ArtistNames")
+                        .EnumerateArray()
+                        .Select(a => a.GetString() ?? "")
+                        .Where(a => !string.IsNullOrEmpty(a))
+                        .ToList()
+                };
+                
+                if (!string.IsNullOrEmpty(track.Title))
+                {
+                    tracks.Add(track);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to parse missing tracks JSON");
+        }
+        
+        return tracks;
+    }
+}

allstarr/Services/Spotify/SpotifyTrackMatchingService.cs

@@ -0,0 +1,260 @@
+using allstarr.Models.Domain;
+using allstarr.Models.Settings;
+using allstarr.Models.Spotify;
+using allstarr.Services.Common;
+using Microsoft.Extensions.Options;
+using System.Text.Json;
+
+namespace allstarr.Services.Spotify;
+
+/// <summary>
+/// Background service that pre-matches Spotify missing tracks with external providers.
+/// Runs after SpotifyMissingTracksFetcher completes to avoid rate limiting during playlist loading.
+/// </summary>
+public class SpotifyTrackMatchingService : BackgroundService
+{
+    private readonly IOptions<SpotifyImportSettings> _spotifySettings;
+    private readonly RedisCacheService _cache;
+    private readonly ILogger<SpotifyTrackMatchingService> _logger;
+    private readonly IServiceProvider _serviceProvider;
+    private const int DelayBetweenSearchesMs = 150; // 150ms = ~6.6 searches/second to avoid rate limiting
+
+    public SpotifyTrackMatchingService(
+        IOptions<SpotifyImportSettings> spotifySettings,
+        RedisCacheService cache,
+        IServiceProvider serviceProvider,
+        ILogger<SpotifyTrackMatchingService> logger)
+    {
+        _spotifySettings = spotifySettings;
+        _cache = cache;
+        _serviceProvider = serviceProvider;
+        _logger = logger;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        _logger.LogInformation("SpotifyTrackMatchingService: Starting up...");
+        
+        if (!_spotifySettings.Value.Enabled)
+        {
+            _logger.LogInformation("Spotify playlist injection is DISABLED, matching service will not run");
+            return;
+        }
+
+        // Wait a bit for the fetcher to run first
+        await Task.Delay(TimeSpan.FromMinutes(2), stoppingToken);
+
+        // Run once on startup to match any existing missing tracks
+        try
+        {
+            _logger.LogInformation("Running initial track matching on startup");
+            await MatchAllPlaylistsAsync(stoppingToken);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during startup track matching");
+        }
+
+        // Now start the periodic matching loop
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            // Wait 30 minutes before next run
+            await Task.Delay(TimeSpan.FromMinutes(30), stoppingToken);
+            
+            try
+            {
+                await MatchAllPlaylistsAsync(stoppingToken);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error in track matching service");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Public method to trigger matching manually (called from controller).
+    /// </summary>
+    public async Task TriggerMatchingAsync()
+    {
+        _logger.LogInformation("Manual track matching triggered");
+        await MatchAllPlaylistsAsync(CancellationToken.None);
+    }
+
+    private async Task MatchAllPlaylistsAsync(CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("=== STARTING TRACK MATCHING ===");
+        
+        var playlists = _spotifySettings.Value.Playlists;
+        if (playlists.Count == 0)
+        {
+            _logger.LogInformation("No playlists configured for matching");
+            return;
+        }
+
+        using var scope = _serviceProvider.CreateScope();
+        var metadataService = scope.ServiceProvider.GetRequiredService<IMusicMetadataService>();
+
+        foreach (var playlist in playlists)
+        {
+            if (cancellationToken.IsCancellationRequested) break;
+            
+            try
+            {
+                await MatchPlaylistTracksAsync(playlist.Name, metadataService, cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error matching tracks for playlist {Playlist}", playlist.Name);
+            }
+        }
+        
+        _logger.LogInformation("=== FINISHED TRACK MATCHING ===");
+    }
+
+    private async Task MatchPlaylistTracksAsync(
+        string playlistName,
+        IMusicMetadataService metadataService,
+        CancellationToken cancellationToken)
+    {
+        var missingTracksKey = $"spotify:missing:{playlistName}";
+        var matchedTracksKey = $"spotify:matched:{playlistName}";
+        
+        // Check if we already have matched tracks cached
+        var existingMatched = await _cache.GetAsync<List<Song>>(matchedTracksKey);
+        if (existingMatched != null && existingMatched.Count > 0)
+        {
+            _logger.LogInformation("Playlist {Playlist} already has {Count} matched tracks cached, skipping", 
+                playlistName, existingMatched.Count);
+            return;
+        }
+
+        // Get missing tracks
+        var missingTracks = await _cache.GetAsync<List<MissingTrack>>(missingTracksKey);
+        if (missingTracks == null || missingTracks.Count == 0)
+        {
+            _logger.LogInformation("No missing tracks found for {Playlist}, skipping matching", playlistName);
+            return;
+        }
+
+        _logger.LogInformation("Matching {Count} tracks for {Playlist} (with rate limiting)", 
+            missingTracks.Count, playlistName);
+
+        var matchedSongs = new List<Song>();
+        var matchCount = 0;
+
+        foreach (var track in missingTracks)
+        {
+            if (cancellationToken.IsCancellationRequested) break;
+
+            try
+            {
+                var query = $"{track.Title} {track.PrimaryArtist}";
+                var results = await metadataService.SearchSongsAsync(query, limit: 5);
+                
+                if (results.Count > 0)
+                {
+                    // Fuzzy match to find best result
+                    // Check that ALL artists match (not just some)
+                    var bestMatch = results
+                        .Select(song => new
+                        {
+                            Song = song,
+                            TitleScore = FuzzyMatcher.CalculateSimilarity(track.Title, song.Title),
+                            // Calculate artist score by checking ALL artists match
+                            ArtistScore = CalculateArtistMatchScore(track.Artists, song.Artist, song.Contributors)
+                        })
+                        .Select(x => new
+                        {
+                            x.Song,
+                            x.TitleScore,
+                            x.ArtistScore,
+                            TotalScore = (x.TitleScore * 0.6) + (x.ArtistScore * 0.4)
+                        })
+                        .OrderByDescending(x => x.TotalScore)
+                        .FirstOrDefault();
+                    
+                    if (bestMatch != null && bestMatch.TotalScore >= 60)
+                    {
+                        matchedSongs.Add(bestMatch.Song);
+                        matchCount++;
+                        
+                        if (matchCount % 10 == 0)
+                        {
+                            _logger.LogInformation("Matched {Count}/{Total} tracks for {Playlist}", 
+                                matchCount, missingTracks.Count, playlistName);
+                        }
+                    }
+                }
+                
+                // Rate limiting: delay between searches
+                await Task.Delay(DelayBetweenSearchesMs, cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogDebug(ex, "Failed to match track: {Title} - {Artist}", 
+                    track.Title, track.PrimaryArtist);
+            }
+        }
+
+        if (matchedSongs.Count > 0)
+        {
+            // Cache matched tracks for 1 hour
+            await _cache.SetAsync(matchedTracksKey, matchedSongs, TimeSpan.FromHours(1));
+            _logger.LogInformation("✓ Cached {Matched}/{Total} matched tracks for {Playlist}", 
+                matchedSongs.Count, missingTracks.Count, playlistName);
+        }
+        else
+        {
+            _logger.LogInformation("No tracks matched for {Playlist}", playlistName);
+        }
+    }
+    
+    /// <summary>
+    /// Calculates artist match score ensuring ALL artists are present.
+    /// Penalizes if artist counts don't match or if any artist is missing.
+    /// </summary>
+    private static double CalculateArtistMatchScore(List<string> spotifyArtists, string songMainArtist, List<string> songContributors)
+    {
+        if (spotifyArtists.Count == 0 || string.IsNullOrEmpty(songMainArtist))
+            return 0;
+        
+        // Build list of all song artists (main + contributors)
+        var allSongArtists = new List<string> { songMainArtist };
+        allSongArtists.AddRange(songContributors);
+        
+        // If artist counts differ significantly, penalize
+        var countDiff = Math.Abs(spotifyArtists.Count - allSongArtists.Count);
+        if (countDiff > 1) // Allow 1 artist difference (sometimes features are listed differently)
+            return 0;
+        
+        // Check that each Spotify artist has a good match in song artists
+        var spotifyScores = new List<double>();
+        foreach (var spotifyArtist in spotifyArtists)
+        {
+            var bestMatch = allSongArtists.Max(songArtist => 
+                FuzzyMatcher.CalculateSimilarity(spotifyArtist, songArtist));
+            spotifyScores.Add(bestMatch);
+        }
+        
+        // Check that each song artist has a good match in Spotify artists
+        var songScores = new List<double>();
+        foreach (var songArtist in allSongArtists)
+        {
+            var bestMatch = spotifyArtists.Max(spotifyArtist => 
+                FuzzyMatcher.CalculateSimilarity(songArtist, spotifyArtist));
+            songScores.Add(bestMatch);
+        }
+        
+        // Average all scores - this ensures ALL artists must match well
+        var allScores = spotifyScores.Concat(songScores);
+        var avgScore = allScores.Average();
+        
+        // Penalize if any individual artist match is poor (< 70)
+        var minScore = allScores.Min();
+        if (minScore < 70)
+            avgScore *= 0.7; // 30% penalty for poor individual match
+        
+        return avgScore;
+    }
+}

allstarr/Services/SquidWTF/SquidWTFDownloadService.cs

@@ -28,6 +28,7 @@ public class SquidWTFDownloadService : BaseDownloadService
     
 	private readonly List<string> _apiUrls;
     private int _currentUrlIndex = 0;
+    private readonly object _urlIndexLock = new object();
 
     protected override string ProviderName => "squidwtf";
 
@@ -48,23 +49,39 @@ public class SquidWTFDownloadService : BaseDownloadService
         _apiUrls = apiUrls;
     }
     
+    /// <summary>
+    /// Tries the request with the next provider in round-robin, then falls back to others on failure.
+    /// This distributes load evenly across all providers while maintaining reliability.
+    /// </summary>
     private async Task<T> TryWithFallbackAsync<T>(Func<string, Task<T>> action)
     {
+        // Start with the next URL in round-robin to distribute load
+        var startIndex = 0;
+        lock (_urlIndexLock)
+        {
+            startIndex = _currentUrlIndex;
+            _currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
+        }
+        
+        // Try all URLs starting from the round-robin selected one
         for (int attempt = 0; attempt < _apiUrls.Count; attempt++)
         {
+            var urlIndex = (startIndex + attempt) % _apiUrls.Count;
+            var baseUrl = _apiUrls[urlIndex];
+            
             try
             {
-                var baseUrl = _apiUrls[_currentUrlIndex];
+                Logger.LogDebug("Trying endpoint {Endpoint} (attempt {Attempt}/{Total})", 
+                    baseUrl, attempt + 1, _apiUrls.Count);
                 return await action(baseUrl);
             }
             catch (Exception ex)
             {
-                Logger.LogWarning(ex, "Request failed with endpoint {Endpoint}, trying next...", _apiUrls[_currentUrlIndex]);
-                _currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
+                Logger.LogWarning(ex, "Request failed with endpoint {Endpoint}, trying next...", baseUrl);
                 
                 if (attempt == _apiUrls.Count - 1)
                 {
-                    Logger.LogError("All SquidWTF endpoints failed");
+                    Logger.LogError("All {Count} SquidWTF endpoints failed", _apiUrls.Count);
                     throw;
                 }
             }
@@ -113,7 +130,8 @@ public class SquidWTFDownloadService : BaseDownloadService
 		
         // Build organized folder structure: Artist/Album/Track using AlbumArtist (fallback to Artist for singles)
         var artistForPath = song.AlbumArtist ?? song.Artist;
-        var outputPath = PathHelper.BuildTrackPath(DownloadPath, artistForPath, song.Album, song.Title, song.Track, extension);
+        var basePath = SubsonicSettings.StorageMode == StorageMode.Cache ? CachePath : DownloadPath;
+        var outputPath = PathHelper.BuildTrackPath(basePath, artistForPath, song.Album, song.Title, song.Track, extension);
         
         // Create directories if they don't exist
         var albumFolder = Path.GetDirectoryName(outputPath)!;

allstarr/Services/SquidWTF/SquidWTFMetadataService.cs

@@ -23,6 +23,7 @@ public class SquidWTFMetadataService : IMusicMetadataService
     private readonly RedisCacheService _cache;
 	private readonly List<string> _apiUrls;
     private int _currentUrlIndex = 0;
+    private readonly object _urlIndexLock = new object();
 
     public SquidWTFMetadataService(
         IHttpClientFactory httpClientFactory, 
@@ -43,25 +44,52 @@ public class SquidWTFMetadataService : IMusicMetadataService
             "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0");
     }
     
-    private string GetCurrentBaseUrl() => _apiUrls[_currentUrlIndex];
+    /// <summary>
+    /// Gets the next URL in round-robin fashion to distribute load across providers
+    /// </summary>
+    private string GetNextBaseUrl()
+    {
+        lock (_urlIndexLock)
+        {
+            var url = _apiUrls[_currentUrlIndex];
+            _currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
+            return url;
+        }
+    }
     
+    /// <summary>
+    /// Tries the request with the next provider in round-robin, then falls back to others on failure.
+    /// This distributes load evenly across all providers while maintaining reliability.
+    /// </summary>
     private async Task<T> TryWithFallbackAsync<T>(Func<string, Task<T>> action, T defaultValue)
     {
+        // Start with the next URL in round-robin to distribute load
+        var startIndex = 0;
+        lock (_urlIndexLock)
+        {
+            startIndex = _currentUrlIndex;
+            _currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
+        }
+        
+        // Try all URLs starting from the round-robin selected one
         for (int attempt = 0; attempt < _apiUrls.Count; attempt++)
         {
+            var urlIndex = (startIndex + attempt) % _apiUrls.Count;
+            var baseUrl = _apiUrls[urlIndex];
+            
             try
             {
-                var baseUrl = _apiUrls[_currentUrlIndex];
+                _logger.LogDebug("Trying endpoint {Endpoint} (attempt {Attempt}/{Total})", 
+                    baseUrl, attempt + 1, _apiUrls.Count);
                 return await action(baseUrl);
             }
             catch (Exception ex)
             {
-                _logger.LogWarning(ex, "Request failed with endpoint {Endpoint}, trying next...", _apiUrls[_currentUrlIndex]);
-                _currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
+                _logger.LogWarning(ex, "Request failed with endpoint {Endpoint}, trying next...", baseUrl);
                 
                 if (attempt == _apiUrls.Count - 1)
                 {
-                    _logger.LogError("All SquidWTF endpoints failed");
+                    _logger.LogError("All {Count} SquidWTF endpoints failed", _apiUrls.Count);
                     return defaultValue;
                 }
             }
@@ -78,11 +106,18 @@ public class SquidWTFMetadataService : IMusicMetadataService
             
             if (!response.IsSuccessStatusCode)
             {
-                return new List<Song>();
+                throw new HttpRequestException($"HTTP {response.StatusCode}");
             }
             
             var json = await response.Content.ReadAsStringAsync();
+            
+            // Check for error in response body
             var result = JsonDocument.Parse(json);
+            if (result.RootElement.TryGetProperty("detail", out _) || 
+                result.RootElement.TryGetProperty("error", out _))
+            {
+                throw new HttpRequestException("API returned error response");
+            }
             
             var songs = new List<Song>();
             if (result.RootElement.TryGetProperty("data", out var data) &&
@@ -188,7 +223,15 @@ public class SquidWTFMetadataService : IMusicMetadataService
 			{
 				foreach(var playlist in items.EnumerateArray())
 				{
-					playlists.Add(ParseTidalPlaylist(playlist));
+					try
+					{
+						playlists.Add(ParseTidalPlaylist(playlist));
+					}
+					catch (Exception ex)
+					{
+						_logger.LogDebug(ex, "Failed to parse playlist, skipping");
+						// Skip this playlist and continue with others
+					}
 				}
 			}
 			return playlists;
@@ -508,26 +551,36 @@ public class SquidWTFMetadataService : IMusicMetadataService
             ? volNum.GetInt32()
             : null;
         
-        // Get artist name - handle both single artist and artists array
+        // Get all artists - Tidal provides both "artist" (singular) and "artists" (plural array)
+        var allArtists = new List<string>();
         string artistName = "";
-        if (track.TryGetProperty("artist", out var artist))
+        string? artistId = null;
+        
+        // Prefer the "artists" array as it includes all collaborators
+        if (track.TryGetProperty("artists", out var artists) && artists.GetArrayLength() > 0)
+        {
+            foreach (var artistEl in artists.EnumerateArray())
+            {
+                var name = artistEl.GetProperty("name").GetString();
+                if (!string.IsNullOrEmpty(name))
+                {
+                    allArtists.Add(name);
+                }
+            }
+            
+            // First artist is the main artist
+            if (allArtists.Count > 0)
+            {
+                artistName = allArtists[0];
+                artistId = $"ext-squidwtf-artist-{artists[0].GetProperty("id").GetInt64()}";
+            }
+        }
+        // Fallback to singular "artist" field
+        else if (track.TryGetProperty("artist", out var artist))
         {
             artistName = artist.GetProperty("name").GetString() ?? "";
-        }
-        else if (track.TryGetProperty("artists", out var artists) && artists.GetArrayLength() > 0)
-        {
-            artistName = artists[0].GetProperty("name").GetString() ?? "";
-        }
-        
-        // Get artist ID
-        string? artistId = null;
-        if (track.TryGetProperty("artist", out var artistForId))
-        {
-            artistId = $"ext-squidwtf-artist-{artistForId.GetProperty("id").GetInt64()}";
-        }
-        else if (track.TryGetProperty("artists", out var artistsForId) && artistsForId.GetArrayLength() > 0)
-        {
-            artistId = $"ext-squidwtf-artist-{artistsForId[0].GetProperty("id").GetInt64()}";
+            artistId = $"ext-squidwtf-artist-{artist.GetProperty("id").GetInt64()}";
+            allArtists.Add(artistName);
         }
         
         // Get album info
@@ -553,6 +606,7 @@ public class SquidWTFMetadataService : IMusicMetadataService
             Title = track.GetProperty("title").GetString() ?? "",
             Artist = artistName,
             ArtistId = artistId,
+            Artists = allArtists,
             Album = albumTitle,
             AlbumId = albumId,
             Duration = track.TryGetProperty("duration", out var duration) 
@@ -606,9 +660,34 @@ public class SquidWTFMetadataService : IMusicMetadataService
             }
         }
         
-        // Get artist info
-        string artistName = track.GetProperty("artist").GetProperty("name").GetString() ?? "";
-        long artistIdNum = track.GetProperty("artist").GetProperty("id").GetInt64();
+        // Get all artists - prefer "artists" array for collaborations
+        var allArtists = new List<string>();
+        string artistName = "";
+        long artistIdNum = 0;
+        
+        if (track.TryGetProperty("artists", out var artists) && artists.GetArrayLength() > 0)
+        {
+            foreach (var artistEl in artists.EnumerateArray())
+            {
+                var name = artistEl.GetProperty("name").GetString();
+                if (!string.IsNullOrEmpty(name))
+                {
+                    allArtists.Add(name);
+                }
+            }
+            
+            if (allArtists.Count > 0)
+            {
+                artistName = allArtists[0];
+                artistIdNum = artists[0].GetProperty("id").GetInt64();
+            }
+        }
+        else if (track.TryGetProperty("artist", out var artist))
+        {
+            artistName = artist.GetProperty("name").GetString() ?? "";
+            artistIdNum = artist.GetProperty("id").GetInt64();
+            allArtists.Add(artistName);
+        }
         
         // Album artist - same as main artist for Tidal tracks
         string? albumArtist = artistName;
@@ -642,6 +721,7 @@ public class SquidWTFMetadataService : IMusicMetadataService
             Title = track.GetProperty("title").GetString() ?? "",
             Artist = artistName,
             ArtistId = $"ext-squidwtf-artist-{artistIdNum}",
+            Artists = allArtists,
             Album = albumTitle,
             AlbumId = $"ext-squidwtf-album-{albumIdNum}",
             AlbumArtist = albumArtist,

allstarr/Services/SquidWTF/SquidWTFStartupValidator.cs

@@ -14,6 +14,7 @@ public class SquidWTFStartupValidator : BaseStartupValidator
     private readonly SquidWTFSettings _settings;
 	private readonly List<string> _apiUrls;
     private int _currentUrlIndex = 0;
+    private readonly object _urlIndexLock = new object();
 
     public override string ServiceName => "SquidWTF";
 
@@ -24,22 +25,37 @@ public class SquidWTFStartupValidator : BaseStartupValidator
         _apiUrls = apiUrls;
     }
     
+    /// <summary>
+    /// Tries the request with the next provider in round-robin, then falls back to others on failure.
+    /// This distributes load evenly across all providers while maintaining reliability.
+    /// </summary>
     private async Task<T> TryWithFallbackAsync<T>(Func<string, Task<T>> action, T defaultValue)
     {
+        // Start with the next URL in round-robin to distribute load
+        var startIndex = 0;
+        lock (_urlIndexLock)
+        {
+            startIndex = _currentUrlIndex;
+            _currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
+        }
+        
+        // Try all URLs starting from the round-robin selected one
         for (int attempt = 0; attempt < _apiUrls.Count; attempt++)
         {
+            var urlIndex = (startIndex + attempt) % _apiUrls.Count;
+            var baseUrl = _apiUrls[urlIndex];
+            
             try
             {
-                var baseUrl = _apiUrls[_currentUrlIndex];
                 return await action(baseUrl);
             }
             catch
             {
-                WriteDetail($"Endpoint {_apiUrls[_currentUrlIndex]} failed, trying next...");
-                _currentUrlIndex = (_currentUrlIndex + 1) % _apiUrls.Count;
+                WriteDetail($"Endpoint {baseUrl} failed, trying next...");
                 
                 if (attempt == _apiUrls.Count - 1)
                 {
+                    WriteDetail($"All {_apiUrls.Count} endpoints failed");
                     return defaultValue;
                 }
             }

allstarr/Services/Validation/StartupValidationOrchestrator.cs

@@ -22,9 +22,13 @@ public class StartupValidationOrchestrator : IHostedService
 
     public async Task StartAsync(CancellationToken cancellationToken)
     {
+        // Get version from assembly
+        var version = typeof(StartupValidationOrchestrator).Assembly
+            .GetName().Version?.ToString(3) ?? "unknown";
+        
         Console.WriteLine();
         Console.WriteLine("========================================");
-        Console.WriteLine("       allstarr starting up...       ");
+        Console.WriteLine($"       allstarr v{version}       ");
         Console.WriteLine("========================================");
         Console.WriteLine();
 

allstarr/allstarr.csproj

@@ -5,6 +5,9 @@
         <Nullable>enable</Nullable>
         <ImplicitUsings>enable</ImplicitUsings>
         <RootNamespace>allstarr</RootNamespace>
+        <Version>1.0.0</Version>
+        <AssemblyVersion>1.0.0.0</AssemblyVersion>
+        <FileVersion>1.0.0.0</FileVersion>
     </PropertyGroup>
 
     <ItemGroup>

allstarr/appsettings.Development.json

@@ -4,5 +4,23 @@
       "Default": "Information",
       "Microsoft.AspNetCore": "Warning"
     }
+  },
+  "SpotifyImport": {
+    "Enabled": false,
+    "SyncStartHour": 16,
+    "SyncStartMinute": 15,
+    "SyncWindowHours": 2,
+    "Playlists": [
+      {
+        "Name": "Release Radar",
+        "SpotifyName": "Release Radar",
+        "Enabled": true
+      },
+      {
+        "Name": "Discover Weekly",
+        "SpotifyName": "Discover Weekly",
+        "Enabled": true
+      }
+    ]
   }
 }

allstarr/appsettings.json

@@ -3,7 +3,7 @@
     "Type": "Subsonic"
   },
   "Subsonic": {
-    "Url": "https://navidrome.local.bransonb.com",
+    "Url": "http://localhost:4533",
     "MusicService": "SquidWTF",
     "ExplicitFilter": "All",
     "DownloadMode": "Track",
@@ -42,5 +42,23 @@
   "Redis": {
     "Enabled": true,
     "ConnectionString": "localhost:6379"
+  },
+  "SpotifyImport": {
+    "Enabled": false,
+    "SyncStartHour": 16,
+    "SyncStartMinute": 15,
+    "SyncWindowHours": 2,
+    "Playlists": [
+      {
+        "Name": "Release Radar",
+        "SpotifyName": "Release Radar",
+        "Enabled": true
+      },
+      {
+        "Name": "Discover Weekly",
+        "SpotifyName": "Discover Weekly",
+        "Enabled": true
+      }
+    ]
   }
 }

docker-compose.yml

@@ -6,12 +6,14 @@ services:
     # Redis is only accessible internally - no external port exposure
     expose:
       - "6379"
-    command: redis-server --maxmemory 256mb --maxmemory-policy allkeys-lru
+    command: redis-server --maxmemory 1gb --maxmemory-policy allkeys-lru --save 60 1 --appendonly yes
     healthcheck:
       test: ["CMD", "redis-cli", "ping"]
       interval: 10s
       timeout: 3s
       retries: 3
+    volumes:
+      - ${REDIS_DATA_PATH:-./redis-data}:/data
     networks:
       - allstarr-network
 
@@ -74,6 +76,16 @@ services:
       - Jellyfin__CacheDurationHours=${CACHE_DURATION_HOURS:-1}
       - Jellyfin__EnableExternalPlaylists=${ENABLE_EXTERNAL_PLAYLISTS:-true}
       
+      # ===== SPOTIFY PLAYLIST INJECTION (JELLYFIN ONLY) =====
+      - SpotifyImport__Enabled=${SPOTIFY_IMPORT_ENABLED:-false}
+      - SpotifyImport__SyncStartHour=${SPOTIFY_IMPORT_SYNC_START_HOUR:-16}
+      - SpotifyImport__SyncStartMinute=${SPOTIFY_IMPORT_SYNC_START_MINUTE:-15}
+      - SpotifyImport__SyncWindowHours=${SPOTIFY_IMPORT_SYNC_WINDOW_HOURS:-2}
+      - SpotifyImport__Playlists=${SPOTIFY_IMPORT_PLAYLISTS:-}
+      - SpotifyImport__PlaylistIds=${SPOTIFY_IMPORT_PLAYLIST_IDS:-}
+      - SpotifyImport__PlaylistNames=${SPOTIFY_IMPORT_PLAYLIST_NAMES:-}
+      - SpotifyImport__PlaylistLocalTracksPositions=${SPOTIFY_IMPORT_PLAYLIST_LOCAL_TRACKS_POSITIONS:-}
+      
       # ===== SHARED =====
       - Library__DownloadPath=/app/downloads
       - SquidWTF__Quality=${SQUIDWTF_QUALITY:-FLAC}
@@ -85,6 +97,8 @@ services:
       - Qobuz__Quality=${QOBUZ_QUALITY:-FLAC}
     volumes:
       - ${DOWNLOAD_PATH:-./downloads}:/app/downloads
+      - ${KEPT_PATH:-./kept}:/app/kept
+      - ${CACHE_PATH:-./cache}:/app/cache
 
 networks:
   allstarr-network:

test-websocket.html

@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>WebSocket Test</title>
+</head>
+<body>
+    <h1>Jellyfin WebSocket Test</h1>
+    <div id="status">Connecting...</div>
+    <div id="messages"></div>
+    
+    <script>
+        // Replace with your actual token and device ID
+        const token = "4d19e81402394d40a7e787222606b3c2";
+        const deviceId = "test-device-123";
+        
+        // Connect to your proxy
+        const wsUrl = `ws://jfm.joshpatra.me/socket?api_key=${token}&deviceId=${deviceId}`;
+        
+        console.log("Connecting to:", wsUrl);
+        document.getElementById('status').textContent = `Connecting to: ${wsUrl}`;
+        
+        const ws = new WebSocket(wsUrl);
+        
+        ws.onopen = () => {
+            console.log("✓ WebSocket connected!");
+            document.getElementById('status').textContent = "✓ Connected!";
+            document.getElementById('status').style.color = "green";
+        };
+        
+        ws.onmessage = (event) => {
+            console.log("Message received:", event.data);
+            const msgDiv = document.createElement('div');
+            msgDiv.textContent = `[${new Date().toLocaleTimeString()}] ${event.data}`;
+            document.getElementById('messages').appendChild(msgDiv);
+        };
+        
+        ws.onerror = (error) => {
+            console.error("WebSocket error:", error);
+            document.getElementById('status').textContent = "✗ Error!";
+            document.getElementById('status').style.color = "red";
+        };
+        
+        ws.onclose = (event) => {
+            console.log("WebSocket closed:", event.code, event.reason);
+            document.getElementById('status').textContent = `✗ Closed (${event.code})`;
+            document.getElementById('status').style.color = "orange";
+        };
+    </script>
+</body>
+</html>