diff --git a/src/NServiceBus.RavenDB.Tests/ApprovalFiles/APIApprovals.ApproveRavenDBPersistence.approved.txt b/src/NServiceBus.RavenDB.Tests/ApprovalFiles/APIApprovals.ApproveRavenDBPersistence.approved.txt
index c1a9f680..38f18df2 100644
--- a/src/NServiceBus.RavenDB.Tests/ApprovalFiles/APIApprovals.ApproveRavenDBPersistence.approved.txt
+++ b/src/NServiceBus.RavenDB.Tests/ApprovalFiles/APIApprovals.ApproveRavenDBPersistence.approved.txt
@@ -1,6 +1,7 @@
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"NServiceBus.RavenDB.ClusterWide.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001007f16e21368ff041183fab592d9e8ed37e7be355e93323147a1d29983d6e591b04282e4da0c9e18bd901e112c0033925eb7d7872c2f1706655891c5c9d57297994f707d16ee9a8f40d978f064ee1ffc73c0db3f4712691b23bf596f75130f4ec978cf78757ec034625a5f27e6bb50c618931ea49f6f628fd74271c32959efb1c5")]
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"NServiceBus.RavenDB.PersistenceTests, PublicKey=00240000048000009400000006020000002400005253413100040000010001007f16e21368ff041183fab592d9e8ed37e7be355e93323147a1d29983d6e591b04282e4da0c9e18bd901e112c0033925eb7d7872c2f1706655891c5c9d57297994f707d16ee9a8f40d978f064ee1ffc73c0db3f4712691b23bf596f75130f4ec978cf78757ec034625a5f27e6bb50c618931ea49f6f628fd74271c32959efb1c5")]
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"NServiceBus.RavenDB.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001007f16e21368ff041183fab592d9e8ed37e7be355e93323147a1d29983d6e591b04282e4da0c9e18bd901e112c0033925eb7d7872c2f1706655891c5c9d57297994f707d16ee9a8f40d978f064ee1ffc73c0db3f4712691b23bf596f75130f4ec978cf78757ec034625a5f27e6bb50c618931ea49f6f628fd74271c32959efb1c5")]
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"NServiceBus.RavenDB.TransactionalSession, PublicKey=0024000004800000940000000602000000240000525341310004000001000100dde965e6172e019ac82c2639ffe494dd2e7dd16347c34762a05732b492e110f2e4e2e1b5ef2d85c848ccfb671ee20a47c8d1376276708dc30a90ff1121b647ba3b7259a6bc383b2034938ef0e275b58b920375ac605076178123693c6c4f1331661a62eba28c249386855637780e3ff5f23a6d854700eaa6803ef48907513b92")]
 namespace NServiceBus.Persistence.RavenDB
 {
     public interface IAsyncSessionProvider
@@ -20,6 +21,7 @@ namespace NServiceBus
 {
     public static class RavenDBOutboxExtensions
     {
+        public static void EndpointName(this NServiceBus.Outbox.OutboxSettings configuration, string endpointName) { }
         public static void SetFrequencyToRunDeduplicationDataCleanup(this NServiceBus.Outbox.OutboxSettings configuration, System.TimeSpan frequencyToRunDeduplicationDataCleanup) { }
         public static void SetTimeToKeepDeduplicationData(this NServiceBus.Outbox.OutboxSettings configuration, System.TimeSpan timeToKeepDeduplicationData) { }
     }
diff --git a/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/CaptureServiceProviderStartupTask.cs b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/CaptureServiceProviderStartupTask.cs
index 624ce141..7f500d45 100644
--- a/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/CaptureServiceProviderStartupTask.cs
+++ b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/CaptureServiceProviderStartupTask.cs
@@ -3,18 +3,11 @@ namespace NServiceBus.TransactionalSession.AcceptanceTests
     using System;
     using System.Threading;
     using System.Threading.Tasks;
-    using NServiceBus.AcceptanceTesting;
-    using NServiceBus.Features;
+    using Features;
 
     public class CaptureServiceProviderStartupTask : FeatureStartupTask
     {
-        public CaptureServiceProviderStartupTask(IServiceProvider serviceProvider, ScenarioContext context)
-        {
-            if (context is IInjectServiceProvider c)
-            {
-                c.ServiceProvider = serviceProvider;
-            }
-        }
+        public CaptureServiceProviderStartupTask(IServiceProvider serviceProvider, TransactionalSessionTestContext context, string endpointName) => context.RegisterServiceProvider(serviceProvider, endpointName);
 
         protected override Task OnStart(IMessageSession session, CancellationToken cancellationToken = default) => Task.CompletedTask;
 
diff --git a/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/DefaultServer.cs b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/DefaultServer.cs
new file mode 100644
index 00000000..5bf259b2
--- /dev/null
+++ b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/DefaultServer.cs
@@ -0,0 +1,57 @@
+namespace NServiceBus.TransactionalSession.AcceptanceTests;
+
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using AcceptanceTesting;
+using AcceptanceTesting.Customization;
+using AcceptanceTesting.Support;
+using Configuration.AdvancedExtensibility;
+using NUnit.Framework;
+
+public class DefaultServer : IEndpointSetupTemplate
+{
+    public virtual async Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointCustomization,
+        Func<EndpointConfiguration, Task> configurationBuilderCustomization)
+    {
+        var endpointConfiguration = new EndpointConfiguration(endpointCustomization.EndpointName);
+
+        endpointConfiguration.EnableInstallers();
+        endpointConfiguration.UseSerialization<SystemJsonSerializer>();
+        endpointConfiguration.Recoverability()
+            .Delayed(delayed => delayed.NumberOfRetries(0))
+            .Immediate(immediate => immediate.NumberOfRetries(0));
+        endpointConfiguration.SendFailedMessagesTo("error");
+
+        var storageDir = Path.Combine(Path.GetTempPath(), "learn", TestContext.CurrentContext.Test.ID);
+
+        endpointConfiguration.UseTransport(new AcceptanceTestingTransport { StorageLocation = storageDir });
+
+        var persistence = endpointConfiguration.UsePersistence<RavenDBPersistence>();
+        persistence.EnableTransactionalSession();
+        persistence.SetDefaultDocumentStore(SetupFixture.DocumentStore);
+        persistence.SetMessageToDatabaseMappingConvention(headers =>
+        {
+            if (headers.TryGetValue("tenant-id", out var tenantValue))
+            {
+                return tenantValue;
+            }
+
+            return SetupFixture.DefaultDatabaseName;
+        });
+
+        endpointConfiguration.GetSettings().Set(persistence);
+
+        if (runDescriptor.ScenarioContext is TransactionalSessionTestContext testContext)
+        {
+            endpointConfiguration.RegisterStartupTask(sp => new CaptureServiceProviderStartupTask(sp, testContext, endpointCustomization.EndpointName));
+        }
+
+        await configurationBuilderCustomization(endpointConfiguration).ConfigureAwait(false);
+
+        // scan types at the end so that all types used by the configuration have been loaded into the AppDomain
+        endpointConfiguration.TypesToIncludeInScan(endpointCustomization.GetTypesScopedByTestClass());
+
+        return endpointConfiguration;
+    }
+}
\ No newline at end of file
diff --git a/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/IInjectServiceProvider.cs b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/IInjectServiceProvider.cs
deleted file mode 100644
index 4e52c963..00000000
--- a/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/IInjectServiceProvider.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-namespace NServiceBus.TransactionalSession.AcceptanceTests
-{
-    using System;
-
-    public interface IInjectServiceProvider
-    {
-        IServiceProvider ServiceProvider { get; set; }
-    }
-}
\ No newline at end of file
diff --git a/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/TransactionSessionDefaultServer.cs b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/TransactionSessionDefaultServer.cs
index c227bc7e..1db8b1b2 100644
--- a/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/TransactionSessionDefaultServer.cs
+++ b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/TransactionSessionDefaultServer.cs
@@ -1,53 +1,18 @@
 namespace NServiceBus.TransactionalSession.AcceptanceTests
 {
     using System;
-    using System.IO;
     using System.Threading.Tasks;
-    using AcceptanceTesting;
-    using AcceptanceTesting.Customization;
     using AcceptanceTesting.Support;
-    using NUnit.Framework;
+    using Configuration.AdvancedExtensibility;
 
-    public class TransactionSessionDefaultServer : IEndpointSetupTemplate
+    public class TransactionSessionDefaultServer : DefaultServer
     {
-        public virtual async Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointCustomization,
-            Func<EndpointConfiguration, Task> configurationBuilderCustomization)
+        public override async Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointCustomization, Func<EndpointConfiguration, Task> configurationBuilderCustomization)
         {
-            var endpointConfiguration = new EndpointConfiguration(endpointCustomization.EndpointName);
+            var endpointConfiguration = await base.GetConfiguration(runDescriptor, endpointCustomization, configurationBuilderCustomization);
 
-            endpointConfiguration.EnableInstallers();
-            endpointConfiguration.UseSerialization<SystemJsonSerializer>();
-            endpointConfiguration.Recoverability()
-                .Delayed(delayed => delayed.NumberOfRetries(0))
-                .Immediate(immediate => immediate.NumberOfRetries(0));
-            endpointConfiguration.SendFailedMessagesTo("error");
-
-            var storageDir = Path.Combine(Path.GetTempPath(), "learn", TestContext.CurrentContext.Test.ID);
-
-            endpointConfiguration.UseTransport(new AcceptanceTestingTransport
-            {
-                StorageLocation = storageDir
-            });
-
-            var persistence = endpointConfiguration.UsePersistence<RavenDBPersistence>();
-            persistence.EnableTransactionalSession();
-            persistence.SetDefaultDocumentStore(SetupFixture.DocumentStore);
-            persistence.SetMessageToDatabaseMappingConvention(headers =>
-            {
-                if (headers.TryGetValue("tenant-id", out var tenantValue))
-                {
-                    return tenantValue;
-                }
-
-                return SetupFixture.DefaultDatabaseName;
-            });
-
-            endpointConfiguration.RegisterStartupTask(sp => new CaptureServiceProviderStartupTask(sp, runDescriptor.ScenarioContext));
-
-            await configurationBuilderCustomization(endpointConfiguration).ConfigureAwait(false);
-
-            // scan types at the end so that all types used by the configuration have been loaded into the AppDomain
-            endpointConfiguration.TypesToIncludeInScan(endpointCustomization.GetTypesScopedByTestClass());
+            endpointConfiguration.GetSettings().Get<PersistenceExtensions<RavenDBPersistence>>()
+                .EnableTransactionalSession();
 
             return endpointConfiguration;
         }
diff --git a/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/TransactionalSessionTestContext.cs b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/TransactionalSessionTestContext.cs
new file mode 100644
index 00000000..93a1e92e
--- /dev/null
+++ b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/Infrastructure/TransactionalSessionTestContext.cs
@@ -0,0 +1,33 @@
+namespace NServiceBus.TransactionalSession.AcceptanceTests;
+
+using System;
+using System.Collections.Concurrent;
+using System.Reflection;
+using AcceptanceTesting;
+
+public class TransactionalSessionTestContext : ScenarioContext
+{
+    public IServiceProvider ServiceProvider
+    {
+        get
+        {
+            var property = typeof(ScenarioContext).GetProperty("CurrentEndpoint", BindingFlags.NonPublic | BindingFlags.Static);
+
+            if (property!.GetValue(this) is not string endpointName)
+            {
+                throw new InvalidOperationException("Access to the service provider of the endpoint is only possible with in a When statement.");
+            }
+
+            if (!serviceProviders.TryGetValue(endpointName, out var serviceProvider))
+            {
+                throw new InvalidOperationException("Could not find service provider for endpoint " + endpointName);
+            }
+
+            return serviceProvider;
+        }
+    }
+
+    public void RegisterServiceProvider(IServiceProvider serviceProvider, string endpointName) => serviceProviders[endpointName] = serviceProvider;
+
+    readonly ConcurrentDictionary<string, IServiceProvider> serviceProviders = new();
+}
\ No newline at end of file
diff --git a/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/When_using_outbox_send_only.cs b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/When_using_outbox_send_only.cs
new file mode 100644
index 00000000..f1a642b1
--- /dev/null
+++ b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/When_using_outbox_send_only.cs
@@ -0,0 +1,82 @@
+namespace NServiceBus.TransactionalSession.AcceptanceTests;
+
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using AcceptanceTesting;
+using AcceptanceTesting.Customization;
+using Configuration.AdvancedExtensibility;
+using NUnit.Framework;
+
+public class When_using_outbox_send_only : NServiceBusAcceptanceTest
+{
+    [Test()]
+    public async Task Should_send_messages_on_transactional_session_commit()
+    {
+        var context = await Scenario.Define<Context>()
+            .WithEndpoint<SendOnlyEndpoint>(s => s.When(async (_, ctx) =>
+            {
+                using var scope = ctx.ServiceProvider.CreateScope();
+                using var transactionalSession = scope.ServiceProvider.GetRequiredService<ITransactionalSession>();
+                await transactionalSession.Open(new RavenDbOpenSessionOptions());
+
+                var options = new SendOptions();
+
+                options.SetDestination(Conventions.EndpointNamingConvention.Invoke(typeof(AnotherEndpoint)));
+
+                await transactionalSession.Send(new SampleMessage(), options);
+
+                await transactionalSession.Commit(CancellationToken.None);
+            }))
+            .WithEndpoint<AnotherEndpoint>()
+            .WithEndpoint<ProcessorEndpoint>()
+            .Done(c => c.MessageReceived)
+            .Run();
+
+        Assert.That(context.MessageReceived, Is.True);
+    }
+
+    class Context : TransactionalSessionTestContext
+    {
+        public bool MessageReceived { get; set; }
+    }
+
+    class SendOnlyEndpoint : EndpointConfigurationBuilder
+    {
+        public SendOnlyEndpoint() => EndpointSetup<DefaultServer>(c =>
+        {
+            var persistence = c.GetSettings().Get<PersistenceExtensions<RavenDBPersistence>>();
+
+            var options = new TransactionalSessionOptions { ProcessorEndpoint = Conventions.EndpointNamingConvention.Invoke(typeof(ProcessorEndpoint)) };
+
+            persistence.EnableTransactionalSession(options);
+
+            c.EnableOutbox();
+            c.SendOnly();
+        });
+    }
+
+    class AnotherEndpoint : EndpointConfigurationBuilder
+    {
+        public AnotherEndpoint() => EndpointSetup<DefaultServer>();
+
+        class SampleHandler(Context testContext) : IHandleMessages<SampleMessage>
+        {
+            public Task Handle(SampleMessage message, IMessageHandlerContext context)
+            {
+                testContext.MessageReceived = true;
+
+                return Task.CompletedTask;
+            }
+        }
+    }
+
+    class ProcessorEndpoint : EndpointConfigurationBuilder
+    {
+        public ProcessorEndpoint() => EndpointSetup<TransactionSessionWithOutboxEndpoint>();
+    }
+
+    class SampleMessage : ICommand
+    {
+    }
+}
\ No newline at end of file
diff --git a/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/When_using_outbox_with_multitenancy.cs b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/When_using_outbox_with_multitenancy.cs
index 706d69d5..3509a6f3 100644
--- a/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/When_using_outbox_with_multitenancy.cs
+++ b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/When_using_outbox_with_multitenancy.cs
@@ -39,10 +39,8 @@ public async Task Should_store_data_on_correct_tenant()
             Assert.That(context.Document.SessionId, Is.EqualTo(context.SessionId), "should have loaded the document from the correct tenant database");
         }
 
-        public class Context : ScenarioContext, IInjectServiceProvider
+        public class Context : TransactionalSessionTestContext
         {
-            public IServiceProvider ServiceProvider { get; set; }
-
             public bool MessageReceived { get; set; }
             public TestDocument Document { get; set; }
             public string SessionId { get; set; }
@@ -52,18 +50,14 @@ public class MultitenantEndpoint : EndpointConfigurationBuilder
         {
             public MultitenantEndpoint() => EndpointSetup<TransactionSessionWithOutboxEndpoint>();
 
-            public class SampleMessageHandler : IHandleMessages<SampleMessage>
+            public class SampleMessageHandler(Context testContext) : IHandleMessages<SampleMessage>
             {
-                public SampleMessageHandler(Context testContext) => this.testContext = testContext;
-
                 public async Task Handle(SampleMessage message, IMessageHandlerContext context)
                 {
                     testContext.MessageReceived = true;
                     var ravenSession = context.SynchronizedStorageSession.RavenSession();
                     testContext.Document = await ravenSession.LoadAsync<TestDocument>(message.DocumentId);
                 }
-
-                readonly Context testContext;
             }
         }
 
diff --git a/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/When_using_transactional_session.cs b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/When_using_transactional_session.cs
index 71977b88..2cebeda5 100644
--- a/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/When_using_transactional_session.cs
+++ b/src/NServiceBus.RavenDB.TransactionalSession.AcceptanceTests/When_using_transactional_session.cs
@@ -129,11 +129,10 @@ public async Task Should_send_immediate_dispatch_messages_even_if_session_is_not
             Assert.That(result.MessageReceived, Is.True);
         }
 
-        class Context : ScenarioContext, IInjectServiceProvider
+        class Context : TransactionalSessionTestContext
         {
             public bool MessageReceived { get; set; }
             public bool CompleteMessageReceived { get; set; }
-            public IServiceProvider ServiceProvider { get; set; }
             public string SessionId { get; set; }
         }
 
@@ -151,32 +150,24 @@ public AnEndpoint()
                 }
             }
 
-            class SampleHandler : IHandleMessages<SampleMessage>
+            class SampleHandler(Context testContext) : IHandleMessages<SampleMessage>
             {
-                public SampleHandler(Context testContext) => this.testContext = testContext;
-
                 public Task Handle(SampleMessage message, IMessageHandlerContext context)
                 {
                     testContext.MessageReceived = true;
 
                     return Task.CompletedTask;
                 }
-
-                readonly Context testContext;
             }
 
-            class CompleteTestMessageHandler : IHandleMessages<CompleteTestMessage>
+            class CompleteTestMessageHandler(Context testContext) : IHandleMessages<CompleteTestMessage>
             {
-                public CompleteTestMessageHandler(Context context) => testContext = context;
-
                 public Task Handle(CompleteTestMessage message, IMessageHandlerContext context)
                 {
                     testContext.CompleteMessageReceived = true;
 
                     return Task.CompletedTask;
                 }
-
-                readonly Context testContext;
             }
         }
 
diff --git a/src/NServiceBus.RavenDB.TransactionalSession.Tests/ApprovalFiles/APIApprovals.Approve.approved.txt b/src/NServiceBus.RavenDB.TransactionalSession.Tests/ApprovalFiles/APIApprovals.Approve.approved.txt
index 9da71ec8..a414b483 100644
--- a/src/NServiceBus.RavenDB.TransactionalSession.Tests/ApprovalFiles/APIApprovals.Approve.approved.txt
+++ b/src/NServiceBus.RavenDB.TransactionalSession.Tests/ApprovalFiles/APIApprovals.Approve.approved.txt
@@ -7,5 +7,6 @@ namespace NServiceBus.TransactionalSession
     public static class RavenDbTransactionalSessionExtensions
     {
         public static NServiceBus.PersistenceExtensions<NServiceBus.RavenDBPersistence> EnableTransactionalSession(this NServiceBus.PersistenceExtensions<NServiceBus.RavenDBPersistence> persistenceExtensions) { }
+        public static NServiceBus.PersistenceExtensions<NServiceBus.RavenDBPersistence> EnableTransactionalSession(this NServiceBus.PersistenceExtensions<NServiceBus.RavenDBPersistence> persistenceExtensions, NServiceBus.TransactionalSession.TransactionalSessionOptions transactionalSessionOptions) { }
     }
 }
\ No newline at end of file
diff --git a/src/NServiceBus.RavenDB.TransactionalSession/NServiceBus.RavenDB.TransactionalSession.csproj b/src/NServiceBus.RavenDB.TransactionalSession/NServiceBus.RavenDB.TransactionalSession.csproj
index 045d383c..6a9b2a9c 100644
--- a/src/NServiceBus.RavenDB.TransactionalSession/NServiceBus.RavenDB.TransactionalSession.csproj
+++ b/src/NServiceBus.RavenDB.TransactionalSession/NServiceBus.RavenDB.TransactionalSession.csproj
@@ -13,7 +13,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="NServiceBus.TransactionalSession" Version="3.2.1" />
+    <PackageReference Include="NServiceBus.TransactionalSession" Version="3.3.0" />
     <PackageReference Include="Particular.Packaging" Version="4.2.2" PrivateAssets="All" />
   </ItemGroup>
 
diff --git a/src/NServiceBus.RavenDB.TransactionalSession/RavenDbTransactionalSessionExtensions.cs b/src/NServiceBus.RavenDB.TransactionalSession/RavenDbTransactionalSessionExtensions.cs
index 9fcbba6f..852c57ed 100644
--- a/src/NServiceBus.RavenDB.TransactionalSession/RavenDbTransactionalSessionExtensions.cs
+++ b/src/NServiceBus.RavenDB.TransactionalSession/RavenDbTransactionalSessionExtensions.cs
@@ -1,7 +1,9 @@
 namespace NServiceBus.TransactionalSession
 {
+    using System;
     using Configuration.AdvancedExtensibility;
     using Features;
+    using Persistence.RavenDB;
 
     /// <summary>
     /// Enables the transactional session feature.
@@ -12,9 +14,29 @@ public static class RavenDbTransactionalSessionExtensions
         /// Enables transactional session for this endpoint.
         /// </summary>
         public static PersistenceExtensions<RavenDBPersistence> EnableTransactionalSession(
-            this PersistenceExtensions<RavenDBPersistence> persistenceExtensions)
+            this PersistenceExtensions<RavenDBPersistence> persistenceExtensions) =>
+            EnableTransactionalSession(persistenceExtensions, new TransactionalSessionOptions());
+
+        /// <summary>
+        /// Enables the transactional session for this endpoint using the specified TransactionalSessionOptions.
+        /// </summary>
+        public static PersistenceExtensions<RavenDBPersistence> EnableTransactionalSession(this PersistenceExtensions<RavenDBPersistence> persistenceExtensions,
+            TransactionalSessionOptions transactionalSessionOptions)
         {
-            persistenceExtensions.GetSettings().EnableFeatureByDefault<RavenDbTransactionalSession>();
+            ArgumentNullException.ThrowIfNull(persistenceExtensions);
+            ArgumentNullException.ThrowIfNull(transactionalSessionOptions);
+
+            var settings = persistenceExtensions.GetSettings();
+
+            settings.Set(transactionalSessionOptions);
+
+            if (!string.IsNullOrWhiteSpace(transactionalSessionOptions.ProcessorEndpoint))
+            {
+                settings.Set(RavenDbOutboxStorage.ProcessorEndpointKey, transactionalSessionOptions.ProcessorEndpoint);
+            }
+
+            settings.EnableFeatureByDefault<RavenDbTransactionalSession>();
+
             return persistenceExtensions;
         }
     }
diff --git a/src/NServiceBus.RavenDB/NServiceBus.RavenDB.csproj b/src/NServiceBus.RavenDB/NServiceBus.RavenDB.csproj
index 3fcbc52b..650d9061 100644
--- a/src/NServiceBus.RavenDB/NServiceBus.RavenDB.csproj
+++ b/src/NServiceBus.RavenDB/NServiceBus.RavenDB.csproj
@@ -25,6 +25,7 @@
     <InternalsVisibleTo Include="NServiceBus.RavenDB.ClusterWide.Tests" Key="$(NServiceBusTestsKey)" />
     <InternalsVisibleTo Include="NServiceBus.RavenDB.PersistenceTests" Key="$(NServiceBusTestsKey)" />
     <InternalsVisibleTo Include="NServiceBus.RavenDB.Tests" Key="$(NServiceBusTestsKey)" />
+    <InternalsVisibleTo Include="NServiceBus.RavenDB.TransactionalSession" Key="$(NServiceBusKey)" />
   </ItemGroup>
 
 </Project>
diff --git a/src/NServiceBus.RavenDB/Outbox/RavenDBOutboxExtensions.cs b/src/NServiceBus.RavenDB/Outbox/RavenDBOutboxExtensions.cs
index 7b258986..5372efbd 100644
--- a/src/NServiceBus.RavenDB/Outbox/RavenDBOutboxExtensions.cs
+++ b/src/NServiceBus.RavenDB/Outbox/RavenDBOutboxExtensions.cs
@@ -20,6 +20,17 @@ public static class RavenDBOutboxExtensions
         public static void SetTimeToKeepDeduplicationData(this OutboxSettings configuration, TimeSpan timeToKeepDeduplicationData) =>
             configuration.GetSettings().SetTimeToKeepDeduplicationData(timeToKeepDeduplicationData);
 
+        /// <summary>
+        /// Sets the endpoint name to use when generating document IDs. This is needed for use cases like configuring a transactional session processor endpoint.
+        /// </summary>
+        public static void EndpointName(this OutboxSettings configuration, string endpointName)
+        {
+            ArgumentNullException.ThrowIfNull(configuration);
+            ArgumentException.ThrowIfNullOrWhiteSpace(endpointName);
+
+            configuration.GetSettings().Set(RavenDbOutboxStorage.ProcessorEndpointKey, endpointName);
+        }
+
         static void SetTimeToKeepDeduplicationData(this SettingsHolder settings, TimeSpan timeToKeepDeduplicationData)
         {
             var now = DateTime.UtcNow;
diff --git a/src/NServiceBus.RavenDB/Outbox/RavenDbOutboxStorage.cs b/src/NServiceBus.RavenDB/Outbox/RavenDbOutboxStorage.cs
index 18d10331..3b952504 100644
--- a/src/NServiceBus.RavenDB/Outbox/RavenDbOutboxStorage.cs
+++ b/src/NServiceBus.RavenDB/Outbox/RavenDbOutboxStorage.cs
@@ -25,9 +25,10 @@ protected override void Setup(FeatureConfigurationContext context)
 
             var timeToKeepDeduplicationData = context.Settings.GetOrDefault<TimeSpan?>(TimeToKeepDeduplicationData) ?? DeduplicationDataTTLDefault;
             var useClusterWideTransactions = context.Settings.GetOrDefault<bool>(RavenDbStorageSession.UseClusterWideTransactions);
+            var endpointName = context.Settings.GetOrDefault<string>(ProcessorEndpointKey) ?? context.Settings.EndpointName();
 
             context.Services.AddTransient<IOutboxStorage>(
-                sp => new OutboxPersister(context.Settings.EndpointName(), sp.GetRequiredService<IOpenTenantAwareRavenSessions>(), timeToKeepDeduplicationData, useClusterWideTransactions));
+                sp => new OutboxPersister(endpointName, sp.GetRequiredService<IOpenTenantAwareRavenSessions>(), timeToKeepDeduplicationData, useClusterWideTransactions));
 
             var frequencyToRunDeduplicationDataCleanup = context.Settings.GetOrDefault<TimeSpan?>(FrequencyToRunDeduplicationDataCleanup) ?? Timeout.InfiniteTimeSpan;
 
@@ -48,6 +49,7 @@ protected override void Setup(FeatureConfigurationContext context)
         }
 
         internal const string TimeToKeepDeduplicationData = "Outbox.TimeToKeepDeduplicationData";
+        internal const string ProcessorEndpointKey = "RavenDB.TransactionalSession.ProcessorEndpoint";
         internal const string FrequencyToRunDeduplicationDataCleanup = "Outbox.FrequencyToRunDeduplicationDataCleanup";
         internal static readonly TimeSpan DeduplicationDataTTLDefault = TimeSpan.FromDays(7);