diff --git a/MediaCleaner/ItemsAdapter.cs b/MediaCleaner/ItemsAdapter.cs
index 1a831a2..180c922 100644
--- a/MediaCleaner/ItemsAdapter.cs
+++ b/MediaCleaner/ItemsAdapter.cs
@@ -1,6 +1,4 @@
-using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
 using Jellyfin.Data.Entities;
 using Jellyfin.Data.Enums;
@@ -33,7 +31,7 @@ public IEnumerable<ExpiredItem> GetPlayedItems(
         CancellationToken cancellationToken)
     {
         var result = new List<ExpiredItem>();
-        var items = GetUserItems(kind, user);
+        var items = GetUserItems(kind, user, ItemSortBy.DatePlayed);
         foreach (var item in items)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -80,15 +78,24 @@ public IEnumerable<ExpiredItem> GetPlayedItems(
 
     public IEnumerable<ExpiredItem> GetNotPlayedItems(
         BaseItemKind kind,
-        IEnumerable<Guid> excludeIds,
+        User user,
         CancellationToken cancellationToken)
     {
         var result = new List<ExpiredItem>();
-        var items = GetItems(kind, excludeIds);
-        foreach ( var item in items )
+        var items = GetUserItems(kind, user, ItemSortBy.DateCreated);
+        foreach (var item in items)
         {
             cancellationToken.ThrowIfCancellationRequested();
+            var userData = _userDataManager.GetUserData(user, item);
 
+            var isWatching = userData.PlaybackPositionTicks != 0;
+            if (userData.Played || isWatching)
+            {
+                _logger.LogTrace("\"{Name}\" ({Id}) was played by {Username}", item.Name, item.Id, user.Username);
+                continue;
+            }
+
+            _logger.LogTrace("\"{Name}\" ({Id}) added because not played by {Username}", item.Name, item.Id, user.Username);
             result.Add(new ExpiredItem
             {
                 Item = item,
@@ -99,20 +106,7 @@ public IEnumerable<ExpiredItem> GetNotPlayedItems(
         return result;
     }
 
-    private IEnumerable<BaseItem> GetItems(BaseItemKind kind, IEnumerable<Guid> excludeIds) =>
-        _libraryManager.GetItemList(
-                new InternalItemsQuery()
-                {
-                    ExcludeItemIds = excludeIds.ToArray(),
-                    IncludeItemTypes = new[]
-                    {
-                        kind,
-                    },
-                    IsVirtualItem = false,
-                    OrderBy = new[] { (ItemSortBy.DateCreated, SortOrder.Descending) }
-                });
-
-    private IEnumerable<BaseItem> GetUserItems(BaseItemKind kind, User user) =>
+    private IEnumerable<BaseItem> GetUserItems(BaseItemKind kind, User user, string sortBy) =>
         _libraryManager.GetItemList(
                 new InternalItemsQuery(user)
                 {
@@ -121,6 +115,6 @@ private IEnumerable<BaseItem> GetUserItems(BaseItemKind kind, User user) =>
                         kind,
                     },
                     IsVirtualItem = false,
-                    OrderBy = new[] { (ItemSortBy.DatePlayed, SortOrder.Descending) }
+                    OrderBy = new[] { (sortBy, SortOrder.Descending) }
                 });
 }
diff --git a/MediaCleaner/JunkCollectors/BaseJunkCollector.cs b/MediaCleaner/JunkCollectors/BaseJunkCollector.cs
index bbe8c09..6203419 100644
--- a/MediaCleaner/JunkCollectors/BaseJunkCollector.cs
+++ b/MediaCleaner/JunkCollectors/BaseJunkCollector.cs
@@ -37,6 +37,7 @@ public virtual List<ExpiredItem> Execute(
             .Select(x => new ExpiredItem
             {
                 Item = x.Key,
+                Kind = x.Select(a => a.Kind).FirstOrDefault(),
                 Data = x.SelectMany(a => a.Data.Select(z => z))
                         .OrderByDescending(a => a.LastPlayedDate)
                         .ToList()
@@ -66,14 +67,20 @@ public virtual List<ExpiredItem> Execute(
     }
 
     public virtual List<ExpiredItem> ExecuteNotPlayed(
-        List<ExpiredItem> expiredPlayedItems,
+        List<User> users,
         IEnumerable<IExpiredItemFilter> filters,
         CancellationToken cancellationToken)
     {
         _logger.LogTrace("Collecting not played items started at {StartTime}", DateTime.Now);
-        var playedIds = expiredPlayedItems.Select(x => x.Item.Id).ToList();
-        var items = _itemsAdapter
-            .GetNotPlayedItems(_kind, playedIds, cancellationToken)
+        var items = users
+            .SelectMany(x => _itemsAdapter.GetNotPlayedItems(_kind, x, cancellationToken))
+            .GroupBy(x => x.Item)
+            .Where(x => x.Count() == users.Count)
+            .Select(x => new ExpiredItem
+            {
+                Item = x.Key,
+                Kind = x.Select(a => a.Kind).FirstOrDefault(),
+            })
             .ToList();
 
         _logger.LogDebug("Filters order: {Filters}", string.Join(", ", filters.Select(x => x.Name)));
diff --git a/MediaCleaner/JunkCollectors/IJunkCollector.cs b/MediaCleaner/JunkCollectors/IJunkCollector.cs
index d38ce44..7662097 100644
--- a/MediaCleaner/JunkCollectors/IJunkCollector.cs
+++ b/MediaCleaner/JunkCollectors/IJunkCollector.cs
@@ -8,6 +8,6 @@ namespace MediaCleaner.JunkCollectors
     internal interface IJunkCollector
     {
         List<ExpiredItem> Execute(List<User> users, IEnumerable<IExpiredItemFilter> filters, CancellationToken cancellationToken);
-        List<ExpiredItem> ExecuteNotPlayed(List<ExpiredItem> expiredPlayedItems, IEnumerable<IExpiredItemFilter> filters, CancellationToken cancellationToken);
+        List<ExpiredItem> ExecuteNotPlayed(List<User> users, IEnumerable<IExpiredItemFilter> filters, CancellationToken cancellationToken);
     }
 }
diff --git a/MediaCleaner/MediaCleanupTask.cs b/MediaCleaner/MediaCleanupTask.cs
index 22ce06d..e0b06e2 100644
--- a/MediaCleaner/MediaCleanupTask.cs
+++ b/MediaCleaner/MediaCleanupTask.cs
@@ -108,14 +108,14 @@ public async Task ExecuteAsync(IProgress<double> progress, CancellationToken can
 
             if (Configuration.KeepMoviesFor >= 0 || Configuration.KeepMoviesNotPlayedFor >= 0)
             {
-                var expiredMovies = CollectMovies(users, usersWithFavorites, itemsAdapter, cancellationToken);
                 if (Configuration.KeepMoviesFor >= 0)
                 {
+                    var expiredMovies = CollectMovies(users, usersWithFavorites, itemsAdapter, cancellationToken);
                     expired.AddRange(expiredMovies);
                 }
                 if (Configuration.KeepMoviesNotPlayedFor >= 0)
                 {
-                    var expiredNotPlayedMovies = CollectNotPlayedMovies(expiredMovies, usersWithFavorites, itemsAdapter, cancellationToken);
+                    var expiredNotPlayedMovies = CollectNotPlayedMovies(users, usersWithFavorites, itemsAdapter, cancellationToken);
                     expiredNotPlayed.AddRange(expiredNotPlayedMovies);
                 }
             }
@@ -123,14 +123,14 @@ public async Task ExecuteAsync(IProgress<double> progress, CancellationToken can
 
             if (Configuration.KeepEpisodesFor >= 0 || Configuration.KeepEpisodesNotPlayedFor >= 0)
             {
-                var expiredSeries = CollectSeries(users, usersWithFavorites, itemsAdapter, cancellationToken);
                 if (Configuration.KeepEpisodesFor >= 0)
                 {
+                    var expiredSeries = CollectSeries(users, usersWithFavorites, itemsAdapter, cancellationToken);
                     expired.AddRange(expiredSeries);
                 }
                 if (Configuration.KeepEpisodesNotPlayedFor >= 0)
                 {
-                    var expiredNotPlayedEpisodes = CollectNotPlayedSeries(expiredSeries, usersWithFavorites, itemsAdapter, cancellationToken);
+                    var expiredNotPlayedEpisodes = CollectNotPlayedSeries(users, usersWithFavorites, itemsAdapter, cancellationToken);
                     expiredNotPlayed.AddRange(expiredNotPlayedEpisodes);
                 }
             }
@@ -138,42 +138,42 @@ public async Task ExecuteAsync(IProgress<double> progress, CancellationToken can
 
             if (Configuration.KeepVideosFor >= 0 || Configuration.KeepVideosNotPlayedFor >= 0)
             {
-                var expiredVideos = CollectVideos(users, usersWithFavorites, itemsAdapter, cancellationToken);
                 if (Configuration.KeepVideosFor >= 0)
                 {
+                    var expiredVideos = CollectVideos(users, usersWithFavorites, itemsAdapter, cancellationToken);
                     expired.AddRange(expiredVideos);
                 }
                 if (Configuration.KeepVideosNotPlayedFor >= 0)
                 {
-                    var expiredNotPlayedVideos = CollectNotPlayedVideos(expiredVideos, usersWithFavorites, itemsAdapter, cancellationToken);
+                    var expiredNotPlayedVideos = CollectNotPlayedVideos(users, usersWithFavorites, itemsAdapter, cancellationToken);
                     expiredNotPlayed.AddRange(expiredNotPlayedVideos);
                 }
             }
 
             if (Configuration.KeepAudioFor >= 0 || Configuration.KeepAudioNotPlayedFor >= 0)
             {
-                var expiredAudio = CollectAudio(users, usersWithFavorites, itemsAdapter, cancellationToken);
                 if (Configuration.KeepAudioFor >= 0)
                 {
+                    var expiredAudio = CollectAudio(users, usersWithFavorites, itemsAdapter, cancellationToken);
                     expired.AddRange(expiredAudio);
                 }
                 if (Configuration.KeepAudioNotPlayedFor >= 0)
                 {
-                    var expiredNotPlayedAudio = CollectNotPlayedAudio(expiredAudio, usersWithFavorites, itemsAdapter, cancellationToken);
+                    var expiredNotPlayedAudio = CollectNotPlayedAudio(users, usersWithFavorites, itemsAdapter, cancellationToken);
                     expiredNotPlayed.AddRange(expiredNotPlayedAudio);
                 }
             }
 
             if (Configuration.KeepAudioBooksFor >= 0 || Configuration.KeepAudioBooksNotPlayedFor >= 0)
             {
-                var expiredAudioBooks = CollectAudioBook(users, usersWithFavorites, itemsAdapter, cancellationToken);
                 if (Configuration.KeepAudioBooksFor >= 0)
                 {
+                    var expiredAudioBooks = CollectAudioBook(users, usersWithFavorites, itemsAdapter, cancellationToken);
                     expired.AddRange(expiredAudioBooks);
                 }
                 if (Configuration.KeepAudioBooksNotPlayedFor >= 0)
                 {
-                    var expiredNotPlayedAudioBooks = CollectNotPlayedAudioBook(expiredAudioBooks, usersWithFavorites, itemsAdapter, cancellationToken);
+                    var expiredNotPlayedAudioBooks = CollectNotPlayedAudioBook(users, usersWithFavorites, itemsAdapter, cancellationToken);
                     expiredNotPlayed.AddRange(expiredNotPlayedAudioBooks);
                 }
             }
@@ -267,7 +267,7 @@ private List<ExpiredItem> CollectMovies(List<User> users, List<User> usersWithFa
             return expiredMovies;
         }
 
-        private IEnumerable<ExpiredItem> CollectNotPlayedMovies(List<ExpiredItem> expiredMovies, List<User> usersWithFavorites, ItemsAdapter itemsAdapter, CancellationToken cancellationToken)
+        private IEnumerable<ExpiredItem> CollectNotPlayedMovies(List<User> users, List<User> usersWithFavorites, ItemsAdapter itemsAdapter, CancellationToken cancellationToken)
         {
             var filters = new List<IExpiredItemFilter>
                 {
@@ -283,7 +283,7 @@ private IEnumerable<ExpiredItem> CollectNotPlayedMovies(List<ExpiredItem> expire
                         _fileSystem)
                 };
             var moviesCollector = new MoviesJunkCollector(_loggerFactory.CreateLogger<MoviesJunkCollector>(), itemsAdapter);
-            var movies = moviesCollector.ExecuteNotPlayed(expiredMovies, filters, cancellationToken);
+            var movies = moviesCollector.ExecuteNotPlayed(users, filters, cancellationToken);
             return movies;
         }
 
@@ -310,7 +310,7 @@ private List<ExpiredItem> CollectSeries(List<User> users, List<User> usersWithFa
             return expiredSeries;
         }
 
-        private IEnumerable<ExpiredItem> CollectNotPlayedSeries(List<ExpiredItem> expiredItems, List<User> usersWithFavorites, ItemsAdapter itemsAdapter, CancellationToken cancellationToken)
+        private IEnumerable<ExpiredItem> CollectNotPlayedSeries(List<User> users, List<User> usersWithFavorites, ItemsAdapter itemsAdapter, CancellationToken cancellationToken)
         {
             var filters = new List<IExpiredItemFilter>
                 {
@@ -327,7 +327,7 @@ private IEnumerable<ExpiredItem> CollectNotPlayedSeries(List<ExpiredItem> expire
                     new SeriesFilter(_loggerFactory.CreateLogger<SeriesFilter>(), Configuration.DeleteEpisodes)
                 };
             var seriesCollector = new SeriesJunkCollector(_loggerFactory.CreateLogger<SeriesJunkCollector>(), itemsAdapter);
-            var expiredSeries = seriesCollector.ExecuteNotPlayed(expiredItems, filters, cancellationToken);
+            var expiredSeries = seriesCollector.ExecuteNotPlayed(users, filters, cancellationToken);
             return expiredSeries;
         }
 
@@ -353,7 +353,7 @@ private List<ExpiredItem> CollectVideos(List<User> users, List<User> usersWithFa
             return expiredVideos;
         }
 
-        private IEnumerable<ExpiredItem> CollectNotPlayedVideos(List<ExpiredItem> expiredItems, List<User> usersWithFavorites, ItemsAdapter itemsAdapter, CancellationToken cancellationToken)
+        private IEnumerable<ExpiredItem> CollectNotPlayedVideos(List<User> users, List<User> usersWithFavorites, ItemsAdapter itemsAdapter, CancellationToken cancellationToken)
         {
             var filters = new List<IExpiredItemFilter>
                 {
@@ -369,7 +369,7 @@ private IEnumerable<ExpiredItem> CollectNotPlayedVideos(List<ExpiredItem> expire
                         _fileSystem)
                 };
             var videosCollector = new VideosJunkCollector(_loggerFactory.CreateLogger<VideosJunkCollector>(), itemsAdapter);
-            var expiredVideos = videosCollector.ExecuteNotPlayed(expiredItems, filters, cancellationToken);
+            var expiredVideos = videosCollector.ExecuteNotPlayed(users, filters, cancellationToken);
             return expiredVideos;
         }
 
@@ -395,7 +395,7 @@ private List<ExpiredItem> CollectAudio(List<User> users, List<User> usersWithFav
             return expiredItems;
         }
 
-        private IEnumerable<ExpiredItem> CollectNotPlayedAudio(List<ExpiredItem> expiredAudio, List<User> usersWithFavorites, ItemsAdapter itemsAdapter, CancellationToken cancellationToken)
+        private IEnumerable<ExpiredItem> CollectNotPlayedAudio(List<User> users, List<User> usersWithFavorites, ItemsAdapter itemsAdapter, CancellationToken cancellationToken)
         {
             var filters = new List<IExpiredItemFilter>
                 {
@@ -411,7 +411,7 @@ private IEnumerable<ExpiredItem> CollectNotPlayedAudio(List<ExpiredItem> expired
                         _fileSystem)
                 };
             var collector = new AudioJunkCollector(_loggerFactory.CreateLogger<AudioJunkCollector>(), itemsAdapter);
-            var expiredItems = collector.ExecuteNotPlayed(expiredAudio, filters, cancellationToken);
+            var expiredItems = collector.ExecuteNotPlayed(users, filters, cancellationToken);
             return expiredItems;
         }
 
@@ -437,7 +437,7 @@ private List<ExpiredItem> CollectAudioBook(List<User> users, List<User> usersWit
             return expiredItems;
         }
 
-        private IEnumerable<ExpiredItem> CollectNotPlayedAudioBook(List<ExpiredItem> expiredAudioBooks, List<User> usersWithFavorites, ItemsAdapter itemsAdapter, CancellationToken cancellationToken)
+        private IEnumerable<ExpiredItem> CollectNotPlayedAudioBook(List<User> users, List<User> usersWithFavorites, ItemsAdapter itemsAdapter, CancellationToken cancellationToken)
         {
             var filters = new List<IExpiredItemFilter>
                 {
@@ -453,7 +453,7 @@ private IEnumerable<ExpiredItem> CollectNotPlayedAudioBook(List<ExpiredItem> exp
                         _fileSystem)
                 };
             var collector = new AudioBookJunkCollector(_loggerFactory.CreateLogger<AudioBookJunkCollector>(), itemsAdapter);
-            var expiredItems = collector.ExecuteNotPlayed(expiredAudioBooks, filters, cancellationToken);
+            var expiredItems = collector.ExecuteNotPlayed(users, filters, cancellationToken);
             return expiredItems;
         }