diff --git a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryScopedAsyncCacheSoakTests.cs b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryScopedAsyncCacheSoakTests.cs
new file mode 100644
index 00000000..70333c99
--- /dev/null
+++ b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryScopedAsyncCacheSoakTests.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BitFaster.Caching.Atomic;
+using BitFaster.Caching.Lru;
+using FluentAssertions;
+using Xunit;
+
+namespace BitFaster.Caching.UnitTests.Atomic
+{
+    [Collection("Soak")]
+    public class AtomicFactoryScopedAsyncCacheSoakTests
+    {
+        private const int capacity = 6;
+        private const int threadCount = 4;
+        private const int soakIterations = 10;
+        private const int loopIterations = 100_000;
+
+#if NET9_0_OR_GREATER
+        [Theory]
+        [Repeat(soakIterations)]
+        public async Task ScopedGetOrAddAsyncAlternateLifetimeIsAlwaysAlive(int _)
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+
+            var run = Threaded.RunAsync(threadCount, async _ =>
+            {
+                var key = new char[8];
+
+                for (int i = 0; i < loopIterations; i++)
+                {
+                    (i + 1).TryFormat(key, out int written);
+
+                    using var lifetime = await alternate.ScopedGetOrAddAsync(key.AsSpan().Slice(0, written), static k => Task.FromResult(new Scoped<Disposable>(new Disposable(int.Parse(k)))));
+                    lifetime.Value.IsDisposed.Should().BeFalse($"ref count {lifetime.ReferenceCount}");
+                }
+            });
+
+            await run;
+        }
+#endif
+    }
+}
diff --git a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryScopedAsyncCacheTests.cs b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryScopedAsyncCacheTests.cs
index 1b7f5c45..f64ceb8e 100644
--- a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryScopedAsyncCacheTests.cs
+++ b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryScopedAsyncCacheTests.cs
@@ -35,6 +35,150 @@ public void ComparerReturnsConfiguredComparer()
 
             cache.Comparer.Should().BeSameAs(comparer);
         }
+
+        [Fact]
+        public async Task TryGetAsyncAlternateLookupCompatibleComparerReturnsLookup()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(1, capacity, StringComparer.Ordinal));
+            using var lifetime = await cache.ScopedGetOrAddAsync("42", _ => Task.FromResult(new Scoped<Disposable>(new Disposable(42))));
+            ReadOnlySpan<char> key = "42";
+
+            cache.TryGetAsyncAlternateLookup<ReadOnlySpan<char>>(out var alternate).Should().BeTrue();
+            alternate.ScopedTryGet(key, out var alternateLifetime).Should().BeTrue();
+            alternateLifetime.Value.State.Should().Be(42);
+            alternateLifetime.Dispose();
+        }
+
+        [Fact]
+        public void GetAsyncAlternateLookupIncompatibleComparerThrowsInvalidOperationException()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(1, capacity, StringComparer.Ordinal));
+
+            Action act = () => cache.GetAsyncAlternateLookup<int>();
+
+            act.Should().Throw<InvalidOperationException>().WithMessage("Incompatible comparer");
+            cache.TryGetAsyncAlternateLookup<int>(out var alternate).Should().BeFalse();
+            alternate.Should().BeNull();
+        }
+
+        [Fact]
+        public async Task TryRemoveExistingKeyReturnsActualKey()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(1, capacity, StringComparer.Ordinal));
+            using var lifetime = await cache.ScopedGetOrAddAsync("42", _ => Task.FromResult(new Scoped<Disposable>(new Disposable(42))));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            ReadOnlySpan<char> key = "42";
+
+            alternate.TryRemove(key, out var actualKey).Should().BeTrue();
+
+            actualKey.Should().Be("42");
+            cache.ScopedTryGet("42", out _).Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task AltScopedGetOrAddAsyncRetrievesCachedValue()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            var factoryCalls = 0;
+            var key = "42";
+
+            using var lifetime1 = await alternate.ScopedGetOrAddAsync(key.AsSpan(), k =>
+            {
+                factoryCalls++;
+                return Task.FromResult(new Scoped<Disposable>(new Disposable(int.Parse(k))));
+            });
+
+            using var lifetime2 = await alternate.ScopedGetOrAddAsync(key.AsSpan(), k =>
+            {
+                factoryCalls++;
+                return Task.FromResult(new Scoped<Disposable>(new Disposable(123)));
+            });
+
+            lifetime1.Value.State.Should().Be(42);
+            lifetime2.Value.State.Should().Be(42);
+            factoryCalls.Should().Be(1);
+        }
+
+        [Fact]
+        public async Task AltScopedGetOrAddArgAsyncRetrievesCachedValue()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            var factoryCalls = 0;
+            var key = "42";
+
+            using var lifetime1 = await alternate.ScopedGetOrAddAsync(key.AsSpan(), (k, offset) =>
+            {
+                factoryCalls++;
+                return Task.FromResult(new Scoped<Disposable>(new Disposable(int.Parse(k) + offset)));
+            }, 1);
+
+            using var lifetime2 = await alternate.ScopedGetOrAddAsync(key.AsSpan(), (k, offset) =>
+            {
+                factoryCalls++;
+                return Task.FromResult(new Scoped<Disposable>(new Disposable(int.Parse(k) + offset)));
+            }, 2);
+
+            lifetime1.Value.State.Should().Be(43);
+            lifetime2.Value.State.Should().Be(43);
+            factoryCalls.Should().Be(1);
+        }
+
+        [Fact]
+        public async Task AltScopedTryGetDisposedScopeReturnsFalse()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(capacity));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            var scope = new Scoped<Disposable>(new Disposable());
+
+            await cache.ScopedGetOrAddAsync("a", _ => Task.FromResult(scope));
+
+            scope.Dispose();
+
+            alternate.ScopedTryGet("a", out var lifetime).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenItemDoesNotExistTryGetAltReturnsFalse()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(capacity));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            alternate.ScopedTryGet("a", out _).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyExistsTryRemoveAltReturnsTrue()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(capacity));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+
+            cache.AddOrUpdate("a", new Disposable());
+            alternate.TryRemove("a", out var key).Should().BeTrue();
+            key.Should().Be("a");
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistTryRemoveAltReturnsFalse()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(capacity));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            alternate.TryRemove("a", out _).Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task GetOrAddAltDisposedScopeThrows()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(capacity));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+
+            var scope = new Scoped<Disposable>(new Disposable());
+            scope.Dispose();
+
+            Func<Task> getOrAdd = async () => { await this.cache.ScopedGetOrAddAsync(1, k => Task.FromResult(scope)); };
+
+            await getOrAdd.Should().ThrowAsync<InvalidOperationException>();
+        }
 #endif
 
         [Fact]
@@ -94,5 +238,77 @@ public void WhenEntryIsUpdatedOldEntryIsDisposed()
             this.cache.TryUpdate(1, new Disposable()).Should().BeTrue();
             disposable2.IsDisposed.Should().BeTrue();
         }
+
+#if NET9_0_OR_GREATER
+
+        [Fact]
+        public async Task ScopedGetOrAddAsyncDisposedScopeThrowsInvalidOperationException()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+
+            var scope = new Scoped<Disposable>(new Disposable());
+            scope.Dispose();
+
+            Func<Task> getOrAdd = async () => { await alternate.ScopedGetOrAddAsync("a", _ => Task.FromResult(scope)); };
+
+            await getOrAdd.Should().ThrowAsync<InvalidOperationException>();
+        }
+
+        [Fact]
+        public void AltTryUpdateMissingKeyReturnsFalse()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            var key = "42";
+
+            alternate.TryUpdate(key.AsSpan(), new Disposable(42)).Should().BeFalse();
+            cache.ScopedTryGet("42", out _).Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task AltTryUpdateExistingKeyUpdatesValue()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            var key = "42";
+
+            using var lifetime = await cache.ScopedGetOrAddAsync("42", _ => Task.FromResult(new Scoped<Disposable>(new Disposable(1))));
+            lifetime.Dispose();
+
+            alternate.TryUpdate(key.AsSpan(), new Disposable(2)).Should().BeTrue();
+
+            alternate.ScopedTryGet(key.AsSpan(), out var updatedLifetime).Should().BeTrue();
+            updatedLifetime.Value.State.Should().Be(2);
+            updatedLifetime.Dispose();
+        }
+
+        [Fact]
+        public void AltAddOrUpdateMissingKeyAddsValue()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            ReadOnlySpan<char> key = "42";
+
+            alternate.AddOrUpdate(key, new Disposable(42));
+            alternate.ScopedTryGet(key, out var lifetime).Should().BeTrue();
+            lifetime.Value.State.Should().Be(42);
+            lifetime.Dispose();
+        }
+
+        [Fact]
+        public void AltAddOrUpdateExistingKeyUpdatesValue()
+        {
+            var cache = new AtomicFactoryScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, ScopedAsyncAtomicFactory<string, Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            ReadOnlySpan<char> key = "42";
+
+            alternate.AddOrUpdate(key, new Disposable(42));
+            alternate.AddOrUpdate(key, new Disposable(43));
+            alternate.ScopedTryGet(key, out var updatedLifetime).Should().BeTrue();
+            updatedLifetime.Value.State.Should().Be(43);
+            updatedLifetime.Dispose();
+        }
+#endif
     }
 }
diff --git a/BitFaster.Caching.UnitTests/ScopedAsyncCacheTests.cs b/BitFaster.Caching.UnitTests/ScopedAsyncCacheTests.cs
index 584b2344..66e1bddf 100644
--- a/BitFaster.Caching.UnitTests/ScopedAsyncCacheTests.cs
+++ b/BitFaster.Caching.UnitTests/ScopedAsyncCacheTests.cs
@@ -30,6 +30,178 @@ public void ComparerReturnsConfiguredComparer()
 
             cache.Comparer.Should().BeSameAs(comparer);
         }
+
+        [Fact]
+        public async Task TryGetAsyncAlternateLookupCompatibleComparerReturnsLookup()
+        {
+            var cache = new ScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, Scoped<Disposable>>(1, capacity, StringComparer.Ordinal));
+            using var lifetime = await cache.ScopedGetOrAddAsync("42", _ => Task.FromResult(new Scoped<Disposable>(new Disposable(42))));
+            ReadOnlySpan<char> key = "42";
+
+            cache.TryGetAsyncAlternateLookup<ReadOnlySpan<char>>(out var alternate).Should().BeTrue();
+            alternate.Should().BeAssignableTo<IScopedAsyncAlternateLookup<ReadOnlySpan<char>, string, Disposable>>();
+        }
+
+        [Fact]
+        public void GetAsyncAlternateLookupIncompatibleComparerThrowsInvalidOperationException()
+        {
+            var cache = new ScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, Scoped<Disposable>>(1, capacity, StringComparer.Ordinal));
+
+            Action act = () => cache.GetAsyncAlternateLookup<int>();
+
+            act.Should().Throw<InvalidOperationException>().WithMessage("Incompatible comparer");
+            cache.TryGetAsyncAlternateLookup<int>(out var alternate).Should().BeFalse();
+            alternate.Should().BeNull();
+        }
+
+        [Fact]
+        public async Task AltTryRemoveExistingKeyReturnsActualKey()
+        {
+            var cache = new ScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, Scoped<Disposable>>(1, capacity, StringComparer.Ordinal));
+            using var lifetime = await cache.ScopedGetOrAddAsync("42", _ => Task.FromResult(new Scoped<Disposable>(new Disposable(42))));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            ReadOnlySpan<char> key = "42";
+
+            alternate.TryRemove(key, out var actualKey).Should().BeTrue();
+
+            actualKey.Should().Be("42");
+            cache.ScopedTryGet("42", out _).Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task AltScopedGetOrAddAsyncMissAndHitUsesActualKey()
+        {
+            var cache = new ScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, Scoped<Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            var factoryCalls = 0;
+            var key = "42";
+
+            using var lifetime1 = await alternate.ScopedGetOrAddAsync(key.AsSpan(), k =>
+            {
+                factoryCalls++;
+                return Task.FromResult(new Scoped<Disposable>(new Disposable(int.Parse(k))));
+            });
+
+            using var lifetime2 = await alternate.ScopedGetOrAddAsync(key.AsSpan(), (k, offset) =>
+            {
+                factoryCalls++;
+                return Task.FromResult(new Scoped<Disposable>(new Disposable(int.Parse(k) + offset)));
+            }, 1);
+
+            lifetime1.Value.State.Should().Be(42);
+            lifetime2.Value.State.Should().Be(42);
+            factoryCalls.Should().Be(1);
+        }
+
+        [Fact]
+        public async Task AltScopedTryGetDisposedScopeReturnsFalse()
+        {
+            var cache = new ScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, Scoped<Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            var scope = new Scoped<Disposable>(new Disposable());
+
+            await cache.ScopedGetOrAddAsync("a", _ => Task.FromResult(scope));
+
+            scope.Dispose();
+
+            alternate.ScopedTryGet("a", out var lifetime).Should().BeFalse();
+        }
+
+        [Fact]
+        public void AltTryRemoveExistingKeyReturnsTrue()
+        {
+            var cache = new ScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, Scoped<Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+
+            cache.AddOrUpdate("a", new Disposable());
+            alternate.TryRemove("a", out var key).Should().BeTrue();
+            key.Should().Be("a");
+        }
+
+        [Fact]
+        public void AltScopedTryGetNonExistentKeyReturnsFalse()
+        {
+            var cache = new ScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, Scoped<Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            alternate.ScopedTryGet("a", out _).Should().BeFalse();
+        }
+
+        [Fact]
+        public void AltTryRemoveNonExistentKeyReturnsFalse()
+        {
+            var cache = new ScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, Scoped<Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            alternate.TryRemove("a", out _).Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task AltScopedGetOrAddAsyncDisposedScopeThrowsInvalidOperationException()
+        {
+            var cache = new ScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, Scoped<Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+
+            var scope = new Scoped<Disposable>(new Disposable());
+            scope.Dispose();
+
+            Func<Task> getOrAdd = async () => { await alternate.ScopedGetOrAddAsync("a", _ => Task.FromResult(scope)); };
+
+            await getOrAdd.Should().ThrowAsync<InvalidOperationException>();
+        }
+
+        [Fact]
+        public void AltTryUpdateMissingKeyReturnsFalse()
+        {
+            var cache = new ScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, Scoped<Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            var key = "42";
+
+            alternate.TryUpdate(key.AsSpan(), new Disposable(42)).Should().BeFalse();
+            cache.ScopedTryGet("42", out _).Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task AltTryUpdateExistingKeyUpdatesValue()
+        {
+            var cache = new ScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, Scoped<Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            var key = "42";
+
+            using var lifetime = await cache.ScopedGetOrAddAsync("42", _ => Task.FromResult(new Scoped<Disposable>(new Disposable(1))));
+            lifetime.Dispose();
+
+            alternate.TryUpdate(key.AsSpan(), new Disposable(2)).Should().BeTrue();
+
+            alternate.ScopedTryGet(key.AsSpan(), out var updatedLifetime).Should().BeTrue();
+            updatedLifetime.Value.State.Should().Be(2);
+            updatedLifetime.Dispose();
+        }
+
+        [Fact]
+        public void AltAddOrUpdateMissingKeyAddsValue()
+        {
+            var cache = new ScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, Scoped<Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            ReadOnlySpan<char> key = "42";
+
+            alternate.AddOrUpdate(key, new Disposable(42));
+            alternate.ScopedTryGet(key, out var lifetime).Should().BeTrue();
+            lifetime.Value.State.Should().Be(42);
+            lifetime.Dispose();
+        }
+
+        [Fact]
+        public void AltAddOrUpdateExistingKeyUpdatesValue()
+        {
+            var cache = new ScopedAsyncCache<string, Disposable>(new ConcurrentLru<string, Scoped<Disposable>>(1, capacity, StringComparer.Ordinal));
+            var alternate = cache.GetAsyncAlternateLookup<ReadOnlySpan<char>>();
+            ReadOnlySpan<char> key = "42";
+
+            alternate.AddOrUpdate(key, new Disposable(42));
+            alternate.AddOrUpdate(key, new Disposable(43));
+            alternate.ScopedTryGet(key, out var updatedLifetime).Should().BeTrue();
+            updatedLifetime.Value.State.Should().Be(43);
+            updatedLifetime.Dispose();
+        }
 #endif
 
         [Fact]
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs
index 3ae7af5d..c901dec1 100644
--- a/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs
@@ -147,6 +147,134 @@ public bool TryUpdate(K key, V value)
         }
 #pragma warning restore CA2000 // Dispose objects before losing scope
 
+#if NET9_0_OR_GREATER
+        ///<inheritdoc/>
+        public IScopedAsyncAlternateLookup<TAlternateKey, K, V> GetAsyncAlternateLookup<TAlternateKey>()
+            where TAlternateKey : notnull, allows ref struct
+        {
+            var inner = this.cache.GetAlternateLookup<TAlternateKey>();
+            var comparer = (IAlternateEqualityComparer<TAlternateKey, K>)this.cache.Comparer;
+            return new AlternateLookup<TAlternateKey>(this.cache, inner, comparer);
+        }
+
+        ///<inheritdoc/>
+        public bool TryGetAsyncAlternateLookup<TAlternateKey>([MaybeNullWhen(false)] out IScopedAsyncAlternateLookup<TAlternateKey, K, V> lookup)
+            where TAlternateKey : notnull, allows ref struct
+        {
+            if (this.cache.TryGetAlternateLookup<TAlternateKey>(out var inner))
+            {
+                var comparer = (IAlternateEqualityComparer<TAlternateKey, K>)this.cache.Comparer;
+                lookup = new AlternateLookup<TAlternateKey>(this.cache, inner, comparer);
+                return true;
+            }
+
+            lookup = default;
+            return false;
+        }
+
+        internal readonly struct AlternateLookup<TAlternateKey> : IScopedAsyncAlternateLookup<TAlternateKey, K, V>
+            where TAlternateKey : notnull, allows ref struct
+        {
+            private readonly ICache<K, ScopedAsyncAtomicFactory<K, V>> cache;
+            private readonly IAlternateLookup<TAlternateKey, K, ScopedAsyncAtomicFactory<K, V>> inner;
+            private readonly IAlternateEqualityComparer<TAlternateKey, K> comparer;
+
+            internal AlternateLookup(ICache<K, ScopedAsyncAtomicFactory<K, V>> cache, IAlternateLookup<TAlternateKey, K, ScopedAsyncAtomicFactory<K, V>> inner, IAlternateEqualityComparer<TAlternateKey, K> comparer)
+            {
+                this.cache = cache;
+                this.inner = inner;
+                this.comparer = comparer;
+            }
+
+            public bool ScopedTryGet(TAlternateKey key, [MaybeNullWhen(false)] out Lifetime<V> lifetime)
+            {
+                if (this.inner.TryGet(key, out var scope) && scope.TryCreateLifetime(out lifetime))
+                {
+                    return true;
+                }
+
+                lifetime = default;
+                return false;
+            }
+
+            public bool TryRemove(TAlternateKey key, [MaybeNullWhen(false)] out K actualKey)
+            {
+                if (this.inner.TryRemove(key, out actualKey, out _))
+                {
+                    return true;
+                }
+
+                actualKey = default;
+                return false;
+            }
+
+#pragma warning disable CA2000 // Dispose objects before losing scope
+            public bool TryUpdate(TAlternateKey key, V value)
+            {
+                return this.inner.TryUpdate(key, new ScopedAsyncAtomicFactory<K, V>(value));
+            }
+
+            public void AddOrUpdate(TAlternateKey key, V value)
+            {
+                this.inner.AddOrUpdate(key, new ScopedAsyncAtomicFactory<K, V>(value));
+            }
+
+            public ValueTask<Lifetime<V>> ScopedGetOrAddAsync(TAlternateKey key, Func<K, Task<Scoped<V>>> valueFactory)
+            {
+                var scope = this.inner.GetOrAdd(key, static _ => new ScopedAsyncAtomicFactory<K, V>());
+
+                if (scope.TryCreateLifetime(out var lifetime))
+                {
+                    return new ValueTask<Lifetime<V>>(lifetime);
+                }
+
+                return ScopedGetOrAddAsync(key, new AsyncValueFactory<K, Scoped<V>>(valueFactory));
+            }
+
+            public ValueTask<Lifetime<V>> ScopedGetOrAddAsync<TArg>(TAlternateKey key, Func<K, TArg, Task<Scoped<V>>> valueFactory, TArg factoryArgument)
+            {
+                var scope = this.inner.GetOrAdd(key, static _ => new ScopedAsyncAtomicFactory<K, V>());
+
+                if (scope.TryCreateLifetime(out var lifetime))
+                {
+                    return new ValueTask<Lifetime<V>>(lifetime);
+                }
+
+                return ScopedGetOrAddAsync(key, new AsyncValueFactoryArg<K, TArg, Scoped<V>>(valueFactory, factoryArgument));
+            }
+#pragma warning restore CA2000 // Dispose objects before losing scope
+
+            private ValueTask<Lifetime<V>> ScopedGetOrAddAsync<TFactory>(TAlternateKey key, TFactory valueFactory) where TFactory : struct, IAsyncValueFactory<K, Scoped<V>>
+            {
+                K actualKey = this.comparer.Create(key);
+                return CompleteAsync(this.cache, actualKey, valueFactory);
+
+                static async ValueTask<Lifetime<V>> CompleteAsync(ICache<K, ScopedAsyncAtomicFactory<K, V>> cache, K actualKey, TFactory valueFactory)
+                {
+                    int c = 0;
+                    var spinwait = new SpinWait();
+
+                    while (true)
+                    {
+                        var scope = cache.GetOrAdd(actualKey, static _ => new ScopedAsyncAtomicFactory<K, V>());
+
+                        var (success, lifetime) = await scope.TryCreateLifetimeAsync(actualKey, valueFactory).ConfigureAwait(false);
+
+                        if (success)
+                        {
+                            return lifetime!;
+                        }
+
+                        spinwait.SpinOnce();
+
+                        if (c++ > ScopedCacheDefaults.MaxRetry)
+                            Throw.ScopedRetryFailure();
+                    }
+                }
+            }
+        }
+#endif
+
         ///<inheritdoc/>
         public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()
         {
diff --git a/BitFaster.Caching/IScopedAsyncAlternateLookup.cs b/BitFaster.Caching/IScopedAsyncAlternateLookup.cs
new file mode 100644
index 00000000..4b9787c8
--- /dev/null
+++ b/BitFaster.Caching/IScopedAsyncAlternateLookup.cs
@@ -0,0 +1,69 @@
+#if NET9_0_OR_GREATER
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+
+namespace BitFaster.Caching
+{
+    /// <summary>
+    /// Provides an async alternate-key lookup over a scoped cache.
+    /// </summary>
+    /// <typeparam name="TAlternateKey">The alternate key type.</typeparam>
+    /// <typeparam name="TKey">The cache key type.</typeparam>
+    /// <typeparam name="TValue">The cache value type.</typeparam>
+    public interface IScopedAsyncAlternateLookup<TAlternateKey, TKey, TValue>
+        where TAlternateKey : notnull, allows ref struct
+        where TKey : notnull
+        where TValue : IDisposable
+    {
+        /// <summary>
+        /// Attempts to get a value lifetime using an alternate key.
+        /// </summary>
+        /// <param name="key">The alternate key.</param>
+        /// <param name="lifetime">The value lifetime when found.</param>
+        /// <returns><see langword="true" /> when the key is found; otherwise, <see langword="false" />.</returns>
+        bool ScopedTryGet(TAlternateKey key, [MaybeNullWhen(false)] out Lifetime<TValue> lifetime);
+
+        /// <summary>
+        /// Attempts to remove a value using an alternate key.
+        /// </summary>
+        /// <param name="key">The alternate key.</param>
+        /// <param name="actualKey">The removed cache key.</param>
+        /// <returns><see langword="true" /> when the key is found; otherwise, <see langword="false" />.</returns>
+        bool TryRemove(TAlternateKey key, [MaybeNullWhen(false)] out TKey actualKey);
+
+        /// <summary>
+        /// Attempts to update an existing value using an alternate key.
+        /// </summary>
+        /// <param name="key">The alternate key.</param>
+        /// <param name="value">The value to update.</param>
+        /// <returns><see langword="true" /> when the key was updated; otherwise, <see langword="false" />.</returns>
+        bool TryUpdate(TAlternateKey key, TValue value);
+
+        /// <summary>
+        /// Adds a value using an alternate key or updates the existing value.
+        /// </summary>
+        /// <param name="key">The alternate key.</param>
+        /// <param name="value">The value to add or update.</param>
+        void AddOrUpdate(TAlternateKey key, TValue value);
+
+        /// <summary>
+        /// Gets an existing value lifetime or adds a new value asynchronously using an alternate key.
+        /// </summary>
+        /// <param name="key">The alternate key.</param>
+        /// <param name="valueFactory">The value factory, invoked with the actual cache key when a value must be created.</param>
+        /// <returns>A task that represents the asynchronous scoped GetOrAdd operation.</returns>
+        ValueTask<Lifetime<TValue>> ScopedGetOrAddAsync(TAlternateKey key, Func<TKey, Task<Scoped<TValue>>> valueFactory);
+
+        /// <summary>
+        /// Gets an existing value lifetime or adds a new value asynchronously using an alternate key and factory argument.
+        /// </summary>
+        /// <typeparam name="TArg">The factory argument type.</typeparam>
+        /// <param name="key">The alternate key.</param>
+        /// <param name="valueFactory">The value factory, invoked with the actual cache key when a value must be created.</param>
+        /// <param name="factoryArgument">The factory argument.</param>
+        /// <returns>A task that represents the asynchronous scoped GetOrAdd operation.</returns>
+        ValueTask<Lifetime<TValue>> ScopedGetOrAddAsync<TArg>(TAlternateKey key, Func<TKey, TArg, Task<Scoped<TValue>>> valueFactory, TArg factoryArgument);
+    }
+}
+#endif
diff --git a/BitFaster.Caching/IScopedAsyncCache.cs b/BitFaster.Caching/IScopedAsyncCache.cs
index b9ecad73..1b1560f3 100644
--- a/BitFaster.Caching/IScopedAsyncCache.cs
+++ b/BitFaster.Caching/IScopedAsyncCache.cs
@@ -46,6 +46,29 @@ public interface IScopedAsyncCache<K, V> : IEnumerable<KeyValuePair<K, Scoped<V>
         /// Gets the key comparer used by the cache.
         /// </summary>
         IEqualityComparer<K> Comparer => throw new NotSupportedException();
+
+// backcompat: add not null constraint to IScopedAsyncCache (where K : notnull)
+#pragma warning disable CS8714 // The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match 'notnull' constraint.
+        /// <summary>
+        /// Gets an async alternate lookup that can use an alternate key type with the configured comparer.
+        /// </summary>
+        /// <typeparam name="TAlternateKey">The alternate key type.</typeparam>
+        /// <returns>An async alternate lookup.</returns>
+        /// <exception cref="InvalidOperationException">The configured comparer does not support <typeparamref name="TAlternateKey" />.</exception>
+        IScopedAsyncAlternateLookup<TAlternateKey, K, V> GetAsyncAlternateLookup<TAlternateKey>()
+            where TAlternateKey : notnull, allows ref struct
+            => throw new NotSupportedException();
+
+        /// <summary>
+        /// Attempts to get an async alternate lookup that can use an alternate key type with the configured comparer.
+        /// </summary>
+        /// <typeparam name="TAlternateKey">The alternate key type.</typeparam>
+        /// <param name="lookup">The async alternate lookup when available.</param>
+        /// <returns><see langword="true" /> when the configured comparer supports <typeparamref name="TAlternateKey" />; otherwise, <see langword="false" />.</returns>
+        bool TryGetAsyncAlternateLookup<TAlternateKey>([MaybeNullWhen(false)] out IScopedAsyncAlternateLookup<TAlternateKey, K, V> lookup)
+            where TAlternateKey : notnull, allows ref struct
+            => throw new NotSupportedException();
+#pragma warning restore CS8714
 #endif
 
         /// <summary>
diff --git a/BitFaster.Caching/ScopedAsyncCache.cs b/BitFaster.Caching/ScopedAsyncCache.cs
index d23d85f2..ff3459a7 100644
--- a/BitFaster.Caching/ScopedAsyncCache.cs
+++ b/BitFaster.Caching/ScopedAsyncCache.cs
@@ -152,6 +152,117 @@ public bool TryUpdate(K key, V value)
         }
 #pragma warning restore CA2000 // Dispose objects before losing scope
 
+#if NET9_0_OR_GREATER
+        ///<inheritdoc/>
+        public IScopedAsyncAlternateLookup<TAlternateKey, K, V> GetAsyncAlternateLookup<TAlternateKey>()
+            where TAlternateKey : notnull, allows ref struct
+        {
+            var inner = this.cache.GetAsyncAlternateLookup<TAlternateKey>();
+            var comparer = (IAlternateEqualityComparer<TAlternateKey, K>)this.cache.Comparer;
+            return new AlternateLookup<TAlternateKey>(this.cache, inner, comparer);
+        }
+
+        ///<inheritdoc/>
+        public bool TryGetAsyncAlternateLookup<TAlternateKey>([MaybeNullWhen(false)] out IScopedAsyncAlternateLookup<TAlternateKey, K, V> lookup)
+            where TAlternateKey : notnull, allows ref struct
+        {
+            if (this.cache.TryGetAsyncAlternateLookup<TAlternateKey>(out var inner))
+            {
+                var comparer = (IAlternateEqualityComparer<TAlternateKey, K>)this.cache.Comparer;
+                lookup = new AlternateLookup<TAlternateKey>(this.cache, inner, comparer);
+                return true;
+            }
+
+            lookup = default;
+            return false;
+        }
+
+        internal readonly struct AlternateLookup<TAlternateKey> : IScopedAsyncAlternateLookup<TAlternateKey, K, V>
+            where TAlternateKey : notnull, allows ref struct
+        {
+            private readonly IAsyncCache<K, Scoped<V>> cache;
+            private readonly IAsyncAlternateLookup<TAlternateKey, K, Scoped<V>> inner;
+            private readonly IAlternateEqualityComparer<TAlternateKey, K> comparer;
+
+            internal AlternateLookup(IAsyncCache<K, Scoped<V>> cache, IAsyncAlternateLookup<TAlternateKey, K, Scoped<V>> inner, IAlternateEqualityComparer<TAlternateKey, K> comparer)
+            {
+                this.cache = cache;
+                this.inner = inner;
+                this.comparer = comparer;
+            }
+
+            public bool ScopedTryGet(TAlternateKey key, [MaybeNullWhen(false)] out Lifetime<V> lifetime)
+            {
+                if (this.inner.TryGet(key, out var scope) && scope.TryCreateLifetime(out lifetime))
+                {
+                    return true;
+                }
+
+                lifetime = default;
+                return false;
+            }
+
+            public bool TryRemove(TAlternateKey key, [MaybeNullWhen(false)] out K actualKey)
+            {
+                if (this.inner.TryRemove(key, out actualKey, out _))
+                {
+                    return true;
+                }
+
+                actualKey = default;
+                return false;
+            }
+
+#pragma warning disable CA2000 // Dispose objects before losing scope
+            public bool TryUpdate(TAlternateKey key, V value)
+            {
+                return this.inner.TryUpdate(key, new Scoped<V>(value));
+            }
+
+            public void AddOrUpdate(TAlternateKey key, V value)
+            {
+                this.inner.AddOrUpdate(key, new Scoped<V>(value));
+            }
+#pragma warning restore CA2000 // Dispose objects before losing scope
+
+            public ValueTask<Lifetime<V>> ScopedGetOrAddAsync(TAlternateKey key, Func<K, Task<Scoped<V>>> valueFactory)
+            {
+                return ScopedGetOrAddAsync(key, new AsyncValueFactory<K, Scoped<V>>(valueFactory));
+            }
+
+            public ValueTask<Lifetime<V>> ScopedGetOrAddAsync<TArg>(TAlternateKey key, Func<K, TArg, Task<Scoped<V>>> valueFactory, TArg factoryArgument)
+            {
+                return ScopedGetOrAddAsync(key, new AsyncValueFactoryArg<K, TArg, Scoped<V>>(valueFactory, factoryArgument));
+            }
+
+            private ValueTask<Lifetime<V>> ScopedGetOrAddAsync<TFactory>(TAlternateKey key, TFactory valueFactory) where TFactory : struct, IAsyncValueFactory<K, Scoped<V>>
+            {
+                K actualKey = this.comparer.Create(key);
+                return CompleteAsync(this.cache, actualKey, valueFactory);
+
+                static async ValueTask<Lifetime<V>> CompleteAsync(IAsyncCache<K, Scoped<V>> cache, K actualKey, TFactory valueFactory)
+                {
+                    int c = 0;
+                    var spinwait = new SpinWait();
+                    while (true)
+                    {
+                        var scope = await cache.GetOrAddAsync(actualKey, static (k, factory) => factory.CreateAsync(k), valueFactory).ConfigureAwait(false);
+
+                        if (scope.TryCreateLifetime(out var lifetime))
+                        {
+                            return lifetime;
+                        }
+
+                        spinwait.SpinOnce();
+
+                        if (c++ > ScopedCacheDefaults.MaxRetry)
+                            Throw.ScopedRetryFailure();
+                    }
+                }
+            }
+        }
+#endif
+
         ///<inheritdoc/>
         public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()
         {