diff --git a/Decorators/MediaSourceManagerDecorator.cs b/Decorators/MediaSourceManagerDecorator.cs
index 870fa19..a0c0343 100644
--- a/Decorators/MediaSourceManagerDecorator.cs
+++ b/Decorators/MediaSourceManagerDecorator.cs
@@ -1,3 +1,4 @@
+using System.Collections.Concurrent;
 using System.Globalization;
 using System.IO;
 using Gelato.Providers;
@@ -18,12 +19,15 @@
 using MediaBrowser.Controller.Persistence;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Controller.Subtitles;
+using MediaBrowser.Controller.Session;
+using MediaBrowser.Controller.SyncPlay;
 using MediaBrowser.Model.Configuration;
 using MediaBrowser.Model.Dlna;
 using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.MediaInfo;
 using MediaBrowser.Model.Providers;
+using MediaBrowser.Model.Session;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Logging;
 
@@ -41,7 +45,9 @@ public sealed class MediaSourceManagerDecorator(
     Lazy<GelatoManager> manager,
     Lazy<SubtitleProvider> subtitleProvider,
     IMediaSegmentManager mediaSegmentManager,
-    IEnumerable<ICustomMetadataProvider<Video>> videoProbeProviders
+    IEnumerable<ICustomMetadataProvider<Video>> videoProbeProviders,
+    Lazy<ISyncPlayManager> syncPlayManager,
+    Lazy<ISessionManager> sessionManager
 ) : IMediaSourceManager
 {
     private readonly IMediaSourceManager _inner =
@@ -61,9 +67,14 @@ IEnumerable<ICustomMetadataProvider<Video>> videoProbeProviders
     private readonly Lazy<SubtitleProvider> _subtitleProvider = subtitleProvider;
 
     //  private readonly Lazy<ISubtitleManager> _subtitleManager = subtitleManager ?? throw new ArgumentNullException(nameof(subtitleManager));
+    private readonly Lazy<ISyncPlayManager> _syncPlayManager = syncPlayManager;
+    private readonly Lazy<ISessionManager> _sessionManager = sessionManager;
     private readonly ICustomMetadataProvider<Video>? _probeProvider =
         videoProbeProviders.FirstOrDefault(p => p.Name == "Probe Provider");
 
+    private static readonly ConcurrentDictionary<string, (string SourceId, DateTime Expiry)> _syncPlaySourceCache = new();
+    private static readonly TimeSpan _syncPlayCacheTtl = TimeSpan.FromMinutes(10);
+
     public IReadOnlyList<MediaSourceInfo> GetStaticMediaSources(
         BaseItem item,
         bool enablePathSubstitution,
@@ -98,13 +109,31 @@ public IReadOnlyList<MediaSourceInfo> GetStaticMediaSources(
 
         var allowSync = ctx.IsInsertableAction() && userId != Guid.Empty;
         var video = item as Video;
-        var cacheKey = Guid.TryParse(video?.PrimaryVersionId, out var id)
+        var itemCacheKey = Guid.TryParse(video?.PrimaryVersionId, out var id)
             ? id.ToString()
             : item.Id.ToString();
 
-        if (userId != Guid.Empty)
+        var cacheKey = userId != Guid.Empty
+            ? $"{userId.ToString()}:{itemCacheKey}"
+            : itemCacheKey;
+
+        // SyncPlay users can reuse streams fetched by any group member,
+        // so check a shared (user-agnostic) key first.
+        var isSyncPlayCacheHit = false;
+        if (allowSync && userId != Guid.Empty)
         {
-            cacheKey = $"{userId.ToString()}:{cacheKey}";
+            try
+            {
+                if (_syncPlayManager.Value.IsUserActive(userId)
+                    && manager.HasStreamSync(itemCacheKey))
+                {
+                    isSyncPlayCacheHit = true;
+                }
+            }
+            catch
+            {
+                // Not critical — fall through to normal per-user check.
+            }
         }
 
         if (!allowSync)
@@ -115,6 +144,12 @@ public IReadOnlyList<MediaSourceInfo> GetStaticMediaSources(
                 uri?.ToString()
             );
         }
+        else if (isSyncPlayCacheHit)
+        {
+            _log.LogDebug(
+                "GetStaticMediaSources: SyncPlay shared cache hit for {ItemId}, skipping SyncStreams",
+                item.Id);
+        }
         else if (uri is not null && !manager.HasStreamSync(cacheKey))
         {
             // Bug in web UI that calls the detail page twice. So that's why there's a lock.
@@ -164,6 +199,7 @@ await _subtitleProvider
                             if (count > 0)
                             {
                                 manager.SetStreamSync(cacheKey);
+                                manager.SetStreamSync(itemCacheKey);
                             }
                         }
                         catch (Exception ex)
@@ -219,12 +255,26 @@ await _subtitleProvider
             };
         }
 
+        // SyncPlay members must see ALL sources so group members can
+        // resolve the same source ID regardless of catalog sync state.
+        var isSyncPlayUser = false;
+        try
+        {
+            isSyncPlayUser = userId != Guid.Empty
+                             && _syncPlayManager.Value.IsUserActive(userId);
+        }
+        catch
+        {
+            // Not critical — fall back to normal per-user filtering.
+        }
+
         var gelatoSources = repo.GetItemList(query)
             .OfType<Video>()
             .Where(x =>
                 x.IsGelato()
                 && (
                     userId == Guid.Empty
+                    || isSyncPlayUser
                     || (x.GelatoData<List<Guid>>("userIds")?.Contains(userId) ?? false)
                 )
             )
@@ -334,10 +384,30 @@ CancellationToken ct
             mediaSourceId
         );
 
+        // SyncPlay: ensure all group members use the same media source.
+        var syncPlayState = ResolveSyncPlaySource(user, item, ctx, mediaSourceId);
+        if (syncPlayState.OverrideSourceId is not null)
+            mediaSourceId = syncPlayState.OverrideSourceId;
+
         var selected = SelectByIdOrFirst(sources, mediaSourceId);
+
+        // Guard: never return a gelato:// or stremio:// virtual source.
+        if (selected is not null && IsVirtualSource(selected))
+        {
+            _log.LogWarning(
+                "GetPlaybackMediaSources: selected source {Id} has virtual path, falling back",
+                selected.Id);
+            selected = sources.FirstOrDefault(s => !IsVirtualSource(s))
+                       ?? sources.FirstOrDefault();
+            if (syncPlayState.CacheKey is not null)
+                _syncPlaySourceCache.TryRemove(syncPlayState.CacheKey, out _);
+        }
+
         if (selected is null)
             return sources;
 
+        UpdateSyncPlayCache(syncPlayState, selected, item, user, ct);
+
         var owner = ResolveOwnerFor(selected, item);
         if (owner.IsPrimaryVersion() && owner.Id != item.Id)
         {
@@ -398,6 +468,10 @@ static bool NeedsProbe(MediaSourceInfo s) =>
             (s.MediaStreams?.All(ms => ms.Type != MediaStreamType.Video) ?? true)
             || (s.RunTimeTicks ?? 0) < TimeSpan.FromMinutes(2).Ticks;
 
+        static bool IsVirtualSource(MediaSourceInfo s) =>
+            s.Path?.StartsWith("gelato", StringComparison.OrdinalIgnoreCase) == true
+            || s.Path?.StartsWith("stremio", StringComparison.OrdinalIgnoreCase) == true;
+
         BaseItem ResolveOwnerFor(MediaSourceInfo s, BaseItem fallback) =>
             Guid.TryParse(s.ETag, out var g) ? libraryManager.GetItemById(g) ?? fallback : fallback;
     }
@@ -610,4 +684,199 @@ await owner.RefreshMetadata(
             }
         }
     }
+
+    /// <summary>
+    /// State bag for SyncPlay source resolution, passed between
+    /// <see cref="ResolveSyncPlaySource"/> and <see cref="UpdateSyncPlayCache"/>.
+    /// </summary>
+    private readonly record struct SyncPlaySourceState(
+        bool IsSyncPlay,
+        string? CacheKey,
+        string? PrevSourceId,
+        Guid? OverrideSourceId,
+        bool HadExplicitSource,
+        string ItemIdStr);
+
+    /// <summary>
+    /// Determines whether the current request is part of a SyncPlay session
+    /// and, if so, resolves the media source the group should be using.
+    /// </summary>
+    private SyncPlaySourceState ResolveSyncPlaySource(
+        User? user, BaseItem item, HttpContext? ctx, Guid? currentMediaSourceId)
+    {
+        var hadExplicit = ctx?.Items.ContainsKey("MediaSourceId") == true;
+        var itemIdStr = item.Id.ToString("N");
+        var empty = new SyncPlaySourceState(false, null, null, null, hadExplicit, itemIdStr);
+
+        if (user is null)
+            return empty;
+
+        bool isSyncPlay;
+        try
+        {
+            isSyncPlay = _syncPlayManager.Value.IsUserActive(user.Id);
+        }
+        catch (Exception ex)
+        {
+            _log.LogWarning(ex, "SyncPlay: IsUserActive check failed for {UserId}", user.Id);
+            return empty;
+        }
+
+        if (!isSyncPlay)
+            return empty;
+
+        try
+        {
+            var groupId = SyncPlayGroupTracker.GetGroupForUser(user.Id);
+            var groupPart = groupId?.ToString("N") ?? "unknown";
+            var cacheKey = $"sp:{groupPart}:{item.Id:N}";
+
+            // Check for a previously cached source.
+            string? prevSourceId = null;
+            if (_syncPlaySourceCache.TryGetValue(cacheKey, out var prev)
+                && prev.Expiry > DateTime.UtcNow)
+            {
+                prevSourceId = prev.SourceId;
+            }
+
+            // If the cache is empty (group just created/joined), seed from
+            // the group leader's session so joiners get the same source.
+            // Only seed with a specific stream ID — the item's own ID is
+            // the default and caching it would block version switching.
+            if (prevSourceId is null)
+            {
+                var groupSessions = _sessionManager.Value.Sessions
+                    .Where(s => SyncPlayGroupTracker.GetGroupForUser(s.UserId) == groupId
+                                && s.NowPlayingItem is not null
+                                && s.NowPlayingItem.Id == item.Id);
+
+                foreach (var gs in groupSessions)
+                {
+                    var msid = gs.PlayState?.MediaSourceId;
+                    if (!string.IsNullOrEmpty(msid) && msid != itemIdStr)
+                    {
+                        prevSourceId = msid;
+                        _syncPlaySourceCache[cacheKey] =
+                            (msid, DateTime.UtcNow + _syncPlayCacheTtl);
+                        _log.LogDebug(
+                            "SyncPlay: seeded cache from group session, source={SourceId}",
+                            msid);
+                        break;
+                    }
+                }
+            }
+
+            // Only override when the cache holds a specific stream ID.
+            Guid? overrideId = null;
+            if (!hadExplicit
+                && prevSourceId is not null
+                && prevSourceId != itemIdStr
+                && Guid.TryParse(prevSourceId, out var cachedId))
+            {
+                _log.LogDebug(
+                    "SyncPlay: overriding mediaSourceId to cached {SourceId} for item {ItemId}",
+                    cachedId, item.Id);
+                overrideId = cachedId;
+            }
+
+            return new SyncPlaySourceState(true, cacheKey, prevSourceId, overrideId, hadExplicit, itemIdStr);
+        }
+        catch (Exception ex)
+        {
+            _log.LogWarning(ex, "SyncPlay: source resolution failed");
+            return new SyncPlaySourceState(true, null, null, null, hadExplicit, itemIdStr);
+        }
+    }
+
+    /// <summary>
+    /// Caches the resolved source for the SyncPlay group and propagates
+    /// explicit version switches to other group members.
+    /// </summary>
+    private void UpdateSyncPlayCache(
+        SyncPlaySourceState state, MediaSourceInfo selected, BaseItem item, User? user, CancellationToken ct)
+    {
+        if (!state.IsSyncPlay || state.CacheKey is null || user is null)
+            return;
+
+        try
+        {
+            // Only cache a specific stream ID — the item's own ID is the
+            // default (sources[0]) and caching it would block version
+            // switching because SyncPlay commands never carry mediaSourceId.
+            if (selected.Id != state.ItemIdStr)
+            {
+                _syncPlaySourceCache[state.CacheKey] =
+                    (selected.Id, DateTime.UtcNow + _syncPlayCacheTtl);
+            }
+
+            if (state.HadExplicitSource
+                && state.PrevSourceId is not null
+                && selected.Id != state.PrevSourceId)
+            {
+                _ = PropagateSourceToGroupAsync(
+                    user.Id, item.Id, selected.Id, ct);
+            }
+        }
+        catch (Exception ex)
+        {
+            _log.LogWarning(ex, "SyncPlay: cache/propagate failed");
+        }
+    }
+
+    /// <summary>
+    /// Sends a PlayNow command to every other session in the same SyncPlay
+    /// group, telling them to switch to the new media source.
+    /// </summary>
+    private async Task PropagateSourceToGroupAsync(
+        Guid initiatorUserId,
+        Guid itemId,
+        string newMediaSourceId,
+        CancellationToken ct)
+    {
+        try
+        {
+            var groupId = SyncPlayGroupTracker.GetGroupForUser(initiatorUserId);
+            if (groupId is null) return;
+
+            // Find the initiator's session (needed as controllingSessionId).
+            var initiatorSession = _sessionManager.Value.Sessions
+                .FirstOrDefault(s => s.UserId == initiatorUserId);
+            if (initiatorSession is null) return;
+
+            // Find other group members' active sessions.
+            var targets = _sessionManager.Value.Sessions
+                .Where(s =>
+                    s.UserId != initiatorUserId
+                    && SyncPlayGroupTracker.GetGroupForUser(s.UserId) == groupId)
+                .ToList();
+
+            foreach (var target in targets)
+            {
+                var command = new PlayRequest
+                {
+                    ItemIds = [itemId],
+                    MediaSourceId = newMediaSourceId,
+                    PlayCommand = PlayCommand.PlayNow,
+                    StartPositionTicks = target.PlayState?.PositionTicks,
+                    ControllingUserId = initiatorUserId,
+                };
+
+                await _sessionManager.Value.SendPlayCommand(
+                    initiatorSession.Id,
+                    target.Id,
+                    command,
+                    ct).ConfigureAwait(false);
+
+                _log.LogDebug(
+                    "SyncPlay: sent source switch to session {SessionId} " +
+                    "(user {UserId}, source {SourceId})",
+                    target.Id, target.UserId, newMediaSourceId);
+            }
+        }
+        catch (Exception ex)
+        {
+            _log.LogWarning(ex,
+                "SyncPlay: failed to propagate source change to group members");
+        }
+    }
 }
diff --git a/Filters/SyncPlayGroupFilter.cs b/Filters/SyncPlayGroupFilter.cs
new file mode 100644
index 0000000..236cd5f
--- /dev/null
+++ b/Filters/SyncPlayGroupFilter.cs
@@ -0,0 +1,125 @@
+using System;
+using System.Reflection;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Controllers;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.Extensions.Logging;
+
+namespace Gelato.Filters;
+
+/// <summary>
+/// Intercepts SyncPlay create/join/leave controller actions to maintain
+/// <see cref="SyncPlayGroupTracker"/>'s userId → groupId mapping.
+/// </summary>
+public sealed class SyncPlayGroupFilter(ILogger<SyncPlayGroupFilter> log) : IAsyncActionFilter, IOrderedFilter
+{
+    // Run before Gelato's other filters so the mapping is ready
+    // when playback requests arrive.
+    public int Order { get; init; } = -1;
+
+    public async Task OnActionExecutionAsync(
+        ActionExecutingContext ctx,
+        ActionExecutionDelegate next)
+    {
+        var actionName = (ctx.ActionDescriptor as ControllerActionDescriptor)?.ActionName;
+
+        if (actionName is not (
+            "SyncPlayCreateGroup" or
+            "SyncPlayJoinGroup" or
+            "SyncPlayLeaveGroup"))
+        {
+            await next();
+            return;
+        }
+
+        log.LogDebug("SyncPlayGroupFilter: intercepted action={Action}", actionName);
+
+        // Execute the actual controller action first.
+        var executed = await next();
+
+        // Only update our map when the action succeeded.
+        if (executed.Exception is not null || executed.Canceled)
+        {
+            log.LogDebug("SyncPlayGroupFilter: action failed or canceled");
+            return;
+        }
+
+        if (!ctx.HttpContext.TryGetUserId(out var userId))
+        {
+            log.LogDebug("SyncPlayGroupFilter: could not get userId from context");
+            return;
+        }
+
+        switch (actionName)
+        {
+            case "SyncPlayCreateGroup":
+                // NewGroup returns Ok(GroupInfoDto) — extract GroupId from the result.
+                if (executed.Result is ObjectResult { Value: { } resultObj })
+                {
+                    var groupIdProp = resultObj.GetType()
+                        .GetProperty("GroupId", BindingFlags.Public | BindingFlags.Instance);
+                    if (groupIdProp?.GetValue(resultObj) is Guid createdGroupId)
+                    {
+                        SyncPlayGroupTracker.SetGroup(userId, createdGroupId);
+                        log.LogInformation(
+                            "SyncPlayGroupFilter: tracked create user={UserId} group={GroupId}",
+                            userId, createdGroupId);
+                    }
+                    else
+                    {
+                        log.LogWarning("SyncPlayGroupFilter: could not extract GroupId from CreateGroup result");
+                    }
+                }
+                else
+                {
+                    log.LogWarning(
+                        "SyncPlayGroupFilter: CreateGroup result was not ObjectResult, was {Type}",
+                        executed.Result?.GetType().Name ?? "null");
+                }
+                break;
+
+            case "SyncPlayJoinGroup":
+                // JoinGroup request body contains GroupId.
+                if (TryGetGroupIdFromArgs(ctx, out var joinedGroupId))
+                {
+                    SyncPlayGroupTracker.SetGroup(userId, joinedGroupId);
+                    log.LogInformation(
+                        "SyncPlayGroupFilter: tracked join user={UserId} group={GroupId}",
+                        userId, joinedGroupId);
+                }
+                else
+                {
+                    log.LogWarning("SyncPlayGroupFilter: could not extract GroupId from join args");
+                }
+                break;
+
+            case "SyncPlayLeaveGroup":
+                SyncPlayGroupTracker.RemoveUser(userId);
+                log.LogDebug("SyncPlayGroupFilter: TRACKED leave user={UserId}", userId);
+                break;
+        }
+    }
+
+    private static bool TryGetGroupIdFromArgs(
+        ActionExecutingContext ctx, out Guid groupId)
+    {
+        groupId = Guid.Empty;
+
+        // Look for requestData argument with a GroupId property.
+        foreach (var kv in ctx.ActionArguments)
+        {
+            if (kv.Value is null) continue;
+
+            var prop = kv.Value.GetType()
+                .GetProperty("GroupId", BindingFlags.Public | BindingFlags.Instance);
+            if (prop?.GetValue(kv.Value) is Guid id && id != Guid.Empty)
+            {
+                groupId = id;
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/ServiceRegistrator.cs b/ServiceRegistrator.cs
index 8844d7e..a9970fc 100644
--- a/ServiceRegistrator.cs
+++ b/ServiceRegistrator.cs
@@ -12,7 +12,9 @@
 using MediaBrowser.Controller.Persistence;
 using MediaBrowser.Controller.Playlists;
 using MediaBrowser.Controller.Plugins;
+using MediaBrowser.Controller.Session;
 using MediaBrowser.Controller.Subtitles;
+using MediaBrowser.Controller.SyncPlay;
 using MediaBrowser.Model.Providers;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
@@ -31,6 +33,7 @@ public void RegisterServices(IServiceCollection services, IServerApplicationHost
         services.AddSingleton<ImageResourceFilter>();
         services.AddSingleton<DeleteResourceFilter>();
         services.AddSingleton<DownloadFilter>();
+        services.AddSingleton<SyncPlayGroupFilter>();
         services.AddSingleton<GelatoManager>();
         services.DecorateSingle<IItemRepository, GelatoItemRepository>();
         services.AddSingleton(sp => (GelatoItemRepository)sp.GetRequiredService<IItemRepository>());
@@ -53,6 +56,13 @@ public void RegisterServices(IServiceCollection services, IServerApplicationHost
         });
         services.AddSingleton<IMediaSegmentProvider, IntroDbSegmentProvider>();
 
+        services.AddSingleton(sp => new Lazy<ISyncPlayManager>(
+            sp.GetRequiredService<ISyncPlayManager>
+        ));
+        services.AddSingleton(sp => new Lazy<ISessionManager>(
+            sp.GetRequiredService<ISessionManager>
+        ));
+
         services.AddHostedService<GelatoService>();
         services
             .DecorateSingle<IDtoService, DtoServiceDecorator>()
@@ -72,6 +82,7 @@ public void RegisterServices(IServiceCollection services, IServerApplicationHost
             o.Filters.AddService<ImageResourceFilter>();
             o.Filters.AddService<DeleteResourceFilter>();
             o.Filters.AddService<DownloadFilter>();
+            o.Filters.AddService<SyncPlayGroupFilter>();
         });
     }
 
diff --git a/SyncPlayGroupTracker.cs b/SyncPlayGroupTracker.cs
new file mode 100644
index 0000000..ccc374d
--- /dev/null
+++ b/SyncPlayGroupTracker.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Concurrent;
+
+namespace Gelato;
+
+/// <summary>
+/// Tracks which SyncPlay group each user belongs to.
+/// Populated by <see cref="Filters.SyncPlayGroupFilter"/> when users
+/// create, join, or leave SyncPlay groups.
+/// </summary>
+internal static class SyncPlayGroupTracker
+{
+    private static readonly ConcurrentDictionary<Guid, Guid> _userGroups = new();
+
+    public static void SetGroup(Guid userId, Guid groupId) =>
+        _userGroups[userId] = groupId;
+
+    public static void RemoveUser(Guid userId) =>
+        _userGroups.TryRemove(userId, out _);
+
+    public static Guid? GetGroupForUser(Guid userId) =>
+        _userGroups.TryGetValue(userId, out var g) ? g : null;
+}