MassTransit vs Wolverine vs Raw RabbitMQ.Client After the License Change

MassTransit v9 (9.2.3 on NuGet) now requires a commercial license with a runtime key on every machine running MassTransit code, including developer laptops, while v8 and earlier remain free under Apache 2.0 but unsupported under the commercial agreement, according to a Softinbit Technology comparison of MassTransit, Wolverine 6 and RabbitMQ.Client 7. The article benchmarks three paths for the same order-processing flow — staying on MassTransit v8 (8.5.11) or licensing v9, migrating to MIT-licensed Wolverine 6 (6.50.0, .NET 9 and 10 only), or writing async consumers directly against RabbitMQ.Client 7 (7.2.2, dual-licensed Apache 2.0 and MPL 2.0) — with retries, error queues and idempotent handling. It recommends MassTransit v9 with a license for teams using sagas, routing slips, the transactional outbox or several transports, and raw RabbitMQ.Client for one or two message types where the team accepts owning retries, error queues, serialization and topology.

Decide whether to license MassTransit v9, stay on v8 for now, move to Wolverine, or write the RabbitMQ code yourself. Note: this article was drafted with AI assistance and reviewed by Softinbit Technology before publishing. It is part of the series The .NET Field Guide. TL;DR — MassTransit v9 moved to a commercial license requiring runtime keys. If you only publish and consume events, you do not need to blindly pay or panic. — Compare three real paths for the same order-processing flow: keep MassTransit v8 open source or v9 licensed , migrate to MIT-licensed Wolverine 6, or write lightweight async consumers with RabbitMQ.Client 7. — Complete benchmarks, topology setups, retry/dead-letter policies, and an outbox comparison to pick the right option for your team. Level: Intermediate · Prerequisites: Basic understanding of message queues and RabbitMQ, ASP.NET Core dependency injection · Reading time: 14 min Dependabot opened a pull request this morning: MassTransit.RabbitMQ 8.5.11 to 9.2.3. The build is green, but the MassTransit docs now say v9 is a commercial product and that the license key must be available at runtime on every machine that runs MassTransit code, developer laptops included. Your Store.Api uses MassTransit for exactly one flow: when an order is placed, publish OrderPlaced, and a consumer reserves stock. You can keep MassTransit v8 for now, or v9 with a license , move to Wolverine, or use RabbitMQ.Client directly. This article builds the same flow in all three, with retries, an error queue, and idempotent handling. The short answer Choose MassTransit v9 with a license when you use sagas, routing slips, the transactional outbox, or several transports, and the subscription cost is smaller than the rewrite. Small organizations should check whether they qualify for the full discount. Choose MassTransit v8 when you need the current code to keep running this quarter, and you put a dated migration or licensing decision on the roadmap. Choose Wolverine when you want an MIT-licensed framework with retries, dead-letter queues, an inbox and outbox, and convention-based handlers, and you run on .NET 9 or 10. Choose raw RabbitMQ.Client when you have one or two message types, want no framework dependency, and accept that you own retries, error queues, serialization, and topology. What is being compared MassTransit is a message bus framework for .NET with consumers, sagas, retries, an outbox, and testing helpers. The current major version is 9 9.2.3 on NuGet in October 2026 , sold by Massient, Inc., the company created by founder Chris Patterson. Version 9 needs a license; the license terms say v8 and earlier “remain free and open source under their original licenses” Apache 2.0 but are unsupported under the commercial agreement. Version 8 still ships patch releases 8.5.11 at the end of September 2026 . Wolverine WolverineFx is a messaging and command-handling framework from JasperFx Software, the team behind Marten. The current major is 6 6.50.0 , released under the MIT license. Wolverine 6 targets .NET 9 and .NET 10 only; teams on .NET 8 must stay on 5.x. RabbitMQ.Client is the official .NET client for RabbitMQ, maintained by the RabbitMQ core team. The current major is 7 7.2.2 , dual-licensed under Apache 2.0 and the Mozilla Public License 2.0. Version 7 made the API fully asynchronous. The same task in each option The task: POST /api/orders/{id}/placed-event publishes OrderPlaced. A consumer reserves stock for each line. Transient failures retry three times with a delay. Permanent failures a product that does not exist go straight to an error queue. A redelivered message never reserves stock twice. Start RabbitMQ locally: docker run -d --name store-rabbit -p 5672:5672 -p 15672:15672 rabbitmq:4-management Add the settings to appsettings.Development.json: { "RabbitMq": { "Host": "localhost", "Username": "guest", "Password": "guest" }} Shared code used by all three options The contract, the idempotency table, and the business logic are identical everywhere. // File: Orders/Messaging/OrderPlaced.csnamespace Store.Api.Orders.Messaging; public sealed record OrderPlaced int OrderId, string UserId, DateTime PlacedAtUtc, IReadOnlyList<OrderPlacedLine Lines ; public sealed record OrderPlacedLine int ProductId, int Quantity ; public interface IOrderEvents{ Task PublishOrderPlacedAsync OrderPlaced message, CancellationToken ct ;} public sealed class ProcessedMessage{ public string Consumer { get; set; } = ""; public string MessageKey { get; set; } = ""; public DateTime ProcessedAtUtc { get; set; }} Register the table in AppDbContext in Store.Api.Data and add a migration: // File: Data/AppDbContext.cs additions; add using Store.Api.Orders.Messaging; public DbSet<ProcessedMessage ProcessedMessages = Set<ProcessedMessage ; js // Inside OnModelCreating:modelBuilder.Entity<ProcessedMessage e = { e.HasKey p = new { p.Consumer, p.MessageKey } ; e.Property p = p.Consumer .HasMaxLength 100 ; e.Property p = p.MessageKey .HasMaxLength 100 ;} ; // File: Orders/Messaging/StockReservationService.csusing Microsoft.EntityFrameworkCore;using Store.Api.Data; namespace Store.Api.Orders.Messaging; public sealed class StockReservationService AppDbContext db, TimeProvider time, ILogger<StockReservationService logger { private const string ConsumerName = "reserve-stock"; public async Task ReserveAsync OrderPlaced message, CancellationToken ct { var key = $"order-{message.OrderId}"; if await db.ProcessedMessages.AnyAsync p = p.Consumer == ConsumerName && p.MessageKey == key, ct { logger.LogInformation "Stock for order {OrderId} already reserved, skipping duplicate", message.OrderId ; return; } js await using var tx = await db.Database.BeginTransactionAsync ct ; foreach var line in message.Lines { // Atomic decrement: two orders reserving the same product cannot overwrite each other. var updated = await db.Products.Where p = p.Id == line.ProductId .ExecuteUpdateAsync s = s.SetProperty p = p.Stock, p = p.Stock - line.Quantity , ct ; if updated == 0 throw new InvalidOperationException $"Product {line.ProductId} does not exist." ; } db.ProcessedMessages.Add new ProcessedMessage { Consumer = ConsumerName, MessageKey = key, ProcessedAtUtc = time.GetUtcNow .UtcDateTime } ; await db.SaveChangesAsync ct ; await tx.CommitAsync ct ; }} The stock updates and the ProcessedMessages row commit in one transaction, so they succeed or fail together. If two copies of the same message race, the composite primary key rejects the second insert with a DbUpdateException, the retry policy runs it again, and the second attempt sees the row and skips. That is why the key is the business identity order-42 and not a transport message id. // File: Orders/OrderEventsController.csusing Microsoft.AspNetCore.Mvc;using Microsoft.EntityFrameworkCore;using Store.Api.Data;using Store.Api.Orders.Messaging; namespace Store.Api.Orders; ApiController Route "api/orders" public sealed class OrderEventsController AppDbContext db, IOrderEvents events : ControllerBase{ HttpPost "{id:int}/placed-event" public async Task<IActionResult PublishPlaced int id, CancellationToken ct { var order = await db.Orders.AsNoTracking .Include o = o.Lines .FirstOrDefaultAsync o = o.Id == id, ct ; if order is null return NotFound ; js var lines = order.Lines.Select l = new OrderPlacedLine l.ProductId, l.Quantity .ToList ; await events.PublishOrderPlacedAsync new OrderPlaced order.Id, order.UserId, order.CreatedAtUtc, lines , ct ; return Accepted ; }} All three options also need builder.Services.AddSingleton TimeProvider.System ; and builder.Services.AddScoped<StockReservationService ; in Program.cs. MassTransit v8 dotnet add package MassTransit.RabbitMQ --version 8.5.11 Pin the version. A plain dotnet add package MassTransit.RabbitMQ now installs v9. // File: Orders/Messaging/MassTransitBus/ReserveStockConsumer.csusing MassTransit; namespace Store.Api.Orders.Messaging.MassTransitBus; public sealed class ReserveStockConsumer StockReservationService reservations : IConsumer<OrderPlaced { public Task Consume ConsumeContext<OrderPlaced context = reservations.ReserveAsync context.Message, context.CancellationToken ;} public sealed class ReserveStockConsumerDefinition : ConsumerDefinition<ReserveStockConsumer { public ReserveStockConsumerDefinition { EndpointName = "order-placed.reserve-stock"; ConcurrentMessageLimit = 10; } protected override void ConfigureConsumer IReceiveEndpointConfigurator endpointConfigurator, IConsumerConfigurator<ReserveStockConsumer consumerConfigurator, IRegistrationContext context { endpointConfigurator.UseMessageRetry r = { r.Ignore<InvalidOperationException ; r.Intervals TimeSpan.FromSeconds 1 , TimeSpan.FromSeconds 5 , TimeSpan.FromSeconds 15 ; } ; }} public sealed class MassTransitOrderEvents IPublishEndpoint publishEndpoint : IOrderEvents{ public Task PublishOrderPlacedAsync OrderPlaced message, CancellationToken ct = publishEndpoint.Publish message, ct ;} // Program.cs, before builder.Build add using MassTransit; and using Store.Api.Orders.Messaging.MassTransitBus; var rabbit = builder.Configuration.GetSection "RabbitMq" ;builder.Services.AddScoped<IOrderEvents, MassTransitOrderEvents ;builder.Services.AddMassTransit x = { x.AddConsumer<ReserveStockConsumer, ReserveStockConsumerDefinition ; x.UsingRabbitMq context, cfg = { cfg.Host rabbit "Host" , "/", h = { h.Username rabbit "Username" ; h.Password rabbit "Password" ; } ; cfg.ConfigureEndpoints context ; } ;} ; ConfigureEndpoints creates the queue order-placed.reserve-stock, an exchange per message type, and the bindings. You never declare topology. UseMessageRetry retries in memory three times. Ignore<InvalidOperationException skips retries for the permanent error. When retries run out, MassTransit moves the message to order-placed.reserve-stock error with the exception details in headers, and publishes a Fault<OrderPlaced you can consume. Delayed redelivery minutes, not seconds is a separate feature that needs a message scheduler, such as the RabbitMQ delayed message exchange plugin. Wolverine dotnet add package WolverineFxdotnet add package WolverineFx.RabbitMQdotnet add package WolverineFx.RuntimeCompilation Since 6.0, runtime code generation is opt-in: add WolverineFx.RuntimeCompilation. It registers itself; opts.UseRuntimeCompilation is needed only when extension auto-discovery is off. // File: Orders/Messaging/WolverineBus/OrderPlacedHandler.csusing Wolverine; namespace Store.Api.Orders.Messaging.WolverineBus; public sealed class OrderPlacedHandler{ public Task Handle OrderPlaced message, StockReservationService reservations, CancellationToken cancellationToken = reservations.ReserveAsync message, cancellationToken ;} public sealed class WolverineOrderEvents IMessageBus bus : IOrderEvents{ public Task PublishOrderPlacedAsync OrderPlaced message, CancellationToken ct = bus.PublishAsync message .AsTask ;} // Program.cs, before builder.Build // add using Wolverine; using Wolverine.ErrorHandling; using Wolverine.RabbitMQ; using Store.Api.Orders.Messaging.WolverineBus; var rabbit = builder.Configuration.GetSection "RabbitMq" ;builder.Services.AddScoped<IOrderEvents, WolverineOrderEvents ;builder.Host.UseWolverine opts = { opts.UseRuntimeCompilation ; // from WolverineFx.RuntimeCompilation opts.UseRabbitMq f = { f.HostName = rabbit "Host" ; f.UserName = rabbit "Username" ; f.Password = rabbit "Password" ; } .AutoProvision ; opts.PublishMessage<OrderPlaced .ToRabbitExchange "store.orders", exchange = exchange.BindQueue "order-placed.reserve-stock" ; opts.ListenToRabbitQueue "order-placed.reserve-stock" .DeadLetterQueueing new DeadLetterQueue "order-placed.reserve-stock.error" ; opts.Policies.OnException<InvalidOperationException .MoveToErrorQueue ; opts.Policies.OnAnyException .RetryWithCooldown TimeSpan.FromSeconds 1 , TimeSpan.FromSeconds 5 , TimeSpan.FromSeconds 15 .Then.MoveToErrorQueue ;} ; No consumer interface. Wolverine finds public classes whose names end in Handler or Consumer and methods named Handle or Consume. Extra parameters StockReservationService, CancellationToken are injected per message. Error rules are checked in order and the first match wins, so the specific rule comes before OnAnyException . A message that matches no rule goes to the error queue. By default Wolverine uses RabbitMQ’s native dead-letter exchange and a shared wolverine-dead-letter-queue. DeadLetterQueueing gives this queue its own error queue. Wolverine’s durable inbox with message storage such as WolverineFx.SqlServer adds deduplication by envelope id. The business-key check above still matters, because a client that publishes the same order twice creates two envelopes. Raw RabbitMQ.Client 7 dotnet add package RabbitMQ.Client Now you write what the frameworks did: a long-lived connection, topology, publisher confirms, a consumer loop, and retries. Retries go to a queue with a 10-second message time to live TTL ; when it expires, RabbitMQ dead-letters the message back to the main queue. // File: Orders/Messaging/RawRabbit/RabbitConnection.csusing RabbitMQ.Client; namespace Store.Api.Orders.Messaging.RawRabbit; public sealed class RabbitConnection IConfiguration configuration : IAsyncDisposable{ private readonly SemaphoreSlim gate = new 1, 1 ; private IConnection? connection; public async Task<IConnection GetAsync CancellationToken ct { if connection is not null return connection; await gate.WaitAsync ct ; try { var section = configuration.GetSection "RabbitMq" ; connection ??= await new ConnectionFactory { HostName = section "Host" , UserName = section "Username" , Password = section "Password" }.CreateConnectionAsync "Store.Api", ct ; return connection; } finally { gate.Release ; } } public async ValueTask DisposeAsync { if connection is not null await connection.DisposeAsync ; }} js public static class RabbitTopology{ public const string Exchange = "store.orders"; public const string RoutingKey = "order.placed"; public const string Queue = "order-placed.reserve-stock"; public const string RetryQueue = Queue + ".retry"; public const string ErrorQueue = Queue + ".error"; public static readonly CreateChannelOptions Confirmed = new publisherConfirmationsEnabled: true, publisherConfirmationTrackingEnabled: true ; public static async Task DeclareAsync IChannel channel, CancellationToken ct { await channel.ExchangeDeclareAsync Exchange, ExchangeType.Topic, durable: true, cancellationToken: ct ; await channel.QueueDeclareAsync Queue, durable: true, exclusive: false, autoDelete: false, cancellationToken: ct ; await channel.QueueBindAsync Queue, Exchange, RoutingKey, cancellationToken: ct ; await channel.QueueDeclareAsync RetryQueue, durable: true, exclusive: false, autoDelete: false, arguments: new Dictionary<string, object? { "x-message-ttl" = 10 000, "x-dead-letter-exchange" = "", "x-dead-letter-routing-key" = Queue }, cancellationToken: ct ; await channel.QueueDeclareAsync ErrorQueue, durable: true, exclusive: false, autoDelete: false, cancellationToken: ct ; }} // File: Orders/Messaging/RawRabbit/RabbitOrderEvents.csusing System.Text.Json;using RabbitMQ.Client; namespace Store.Api.Orders.Messaging.RawRabbit; public sealed class RabbitOrderEvents RabbitConnection rabbit : IOrderEvents, IAsyncDisposable{ private readonly SemaphoreSlim gate = new 1, 1 ; private IChannel? channel; public async Task PublishOrderPlacedAsync OrderPlaced message, CancellationToken ct { await gate.WaitAsync ct ; try { if channel is null { channel = await await rabbit.GetAsync ct .CreateChannelAsync RabbitTopology.Confirmed, ct ; await RabbitTopology.DeclareAsync channel, ct ; } js var properties = new BasicProperties { Persistent = true, ContentType = "application/json", MessageId = $"order-{message.OrderId}", Type = nameof OrderPlaced }; await channel.BasicPublishAsync RabbitTopology.Exchange, RabbitTopology.RoutingKey, mandatory: true, basicProperties: properties, body: JsonSerializer.SerializeToUtf8Bytes message , cancellationToken: ct ; } finally { gate.Release ; } } public async ValueTask DisposeAsync { if channel is not null await channel.DisposeAsync ; }} // File: Orders/Messaging/RawRabbit/ReserveStockWorker.csusing System.Text.Json;using RabbitMQ.Client;using RabbitMQ.Client.Events; namespace Store.Api.Orders.Messaging.RawRabbit; public sealed class ReserveStockWorker RabbitConnection rabbit, IServiceScopeFactory scopes, ILogger<ReserveStockWorker logger : BackgroundService{ private const int MaxRetries = 3; private const string RetryHeader = "x-retry-count"; private IChannel? consumeChannel; private IChannel? publishChannel; protected override async Task ExecuteAsync CancellationToken stoppingToken { var connection = await rabbit.GetAsync stoppingToken ; publishChannel = await connection.CreateChannelAsync RabbitTopology.Confirmed, stoppingToken ; consumeChannel = await connection.CreateChannelAsync cancellationToken: stoppingToken ; await RabbitTopology.DeclareAsync consumeChannel, stoppingToken ; await consumeChannel.BasicQosAsync prefetchSize: 0, prefetchCount: 10, global: false, stoppingToken ; js var consumer = new AsyncEventingBasicConsumer consumeChannel ; consumer.ReceivedAsync += HandleAsync; await consumeChannel.BasicConsumeAsync RabbitTopology.Queue, autoAck: false, consumer, stoppingToken ; try { await Task.Delay Timeout.Infinite, stoppingToken ; } catch OperationCanceledException { } } private async Task HandleAsync object sender, BasicDeliverEventArgs delivery { try { var message = JsonSerializer.Deserialize<OrderPlaced delivery.Body.Span ?? throw new InvalidOperationException "Empty OrderPlaced message." ; await using var scope = scopes.CreateAsyncScope ; await scope.ServiceProvider.GetRequiredService<StockReservationService .ReserveAsync message, delivery.CancellationToken ; } catch Exception ex { var attempt = ReadRetryCount delivery.BasicProperties + 1; var permanent = ex is JsonException or InvalidOperationException; var target = permanent || attempt MaxRetries ? RabbitTopology.ErrorQueue : RabbitTopology.RetryQueue; logger.LogWarning ex, "OrderPlaced failed on attempt {Attempt}, moving it to {Queue}", attempt, target ; js var properties = new BasicProperties delivery.BasicProperties { Headers = new Dictionary<string, object? delivery.BasicProperties.Headers ?? new Dictionary<string, object? { RetryHeader = attempt, "x-last-error" = ex.Message } }; await publishChannel .BasicPublishAsync "", target, mandatory: true, basicProperties: properties, body: delivery.Body ; } await consumeChannel .BasicAckAsync delivery.DeliveryTag, multiple: false ; } js private static int ReadRetryCount IReadOnlyBasicProperties properties = properties.Headers is not null && properties.Headers.TryGetValue RetryHeader, out var value ? value switch { int i = i, long l = int l, = 0 } : 0;} // Program.cs, before builder.Build add using Store.Api.Orders.Messaging.RawRabbit; builder.Services.AddSingleton<RabbitConnection ;builder.Services.AddSingleton<IOrderEvents, RabbitOrderEvents ;builder.Services.AddHostedService<ReserveStockWorker ; Publisher confirms make BasicPublishAsync wait for the broker to accept the message, and mandatory: true turns "no queue bound" into an exception instead of a silent drop. The failed copy is republished on a separate confirmed channel before the original is acknowledged. If the process dies between those two steps, the message is delivered twice, and the idempotency check absorbs it. Publish order 42 twice with any option and the logs show the guard working: Learning curve: MassTransit: Medium large feature set | Wolverine: Medium conventions & code generation | RabbitMQ.Client: Low API surface, but requires deep AMQP knowledge You run MassTransit sagas or routing slips in production. Price the v9 license first. Rewriting state machines costs more than most subscriptions, and v9 includes the fixes from the v8 codebase. You use MassTransit only for publish and consume. Wolverine is the shortest move: the handler is smaller than the consumer, and retry rules map almost one to one. You are still on .NET 8 and cannot upgrade soon. Stay on MassTransit v8 or use Wolverine 5.x; Wolverine 6 will not install. You have one integration and a team that knows RabbitMQ. Raw RabbitMQ.Client is fine, but budget for the parts this article skipped: recovery logging, metrics, and tests for the retry path. Your company is small. Massient states that organizations under 1 million US dollars in gross annual revenue may qualify for a full discount on the license commercial support excluded . Check the current terms before you decide on cost alone. Switching later What changes if you stay on MassTransit v8 Pin the major version so tooling does not upgrade you by accident: <PackageReference Include="MassTransit.RabbitMQ" Version=" 8.5.11,9.0 " / .github/dependabot.yml inside the nuget update entry ignore: - dependency-name: "MassTransit " update-types: "version-update:semver-major" Plan for the end of fixes. When v9 was announced in 2025, the plan was security patches and critical fixes for v8 through the end of 2026. After that, assume no fixes and check the MassTransit support page for the current statement. Upgrading to v9 later is mostly mechanical. The v9 upgrade notes list TransactionalBus removal, per-bus JSON settings, AddSendEndpointConvention renamed to AddMessageRoute, and changed outbox tables in 9.1. You also add the license through MT LICENSE, MT LICENSE PATH, cfg.SetLicense ... , or cfg.SetLicenseLocation ... . MassTransit to Wolverine Move one consumer at a time. Wolverine can read and write MassTransit’s envelope format on dedicated endpoints with .UseMassTransitInterop on ListenToRabbitQueue ... and ToRabbitExchange ... . Rename consumers to handlers: Consume ConsumeContext<T becomes Handle T message, ...dependencies . Queues that MassTransit declared do not have Wolverine’s x-dead-letter-exchange argument, and RabbitMQ refuses a redeclare with different arguments. Use new DeadLetterQueue "name", DeadLetterQueueMode.InteropFriendly or new queue names. Raw client to a framework Your messages are plain JSON with no envelope. MassTransit reads them with e.UseRawJsonDeserializer on the receive endpoint; Wolverine uses .DefaultIncomingMessage<OrderPlaced on the listener. Drain the custom .retry queue before you delete it, or messages waiting there will dead-letter into a queue nobody reads. Common pitfalls Publishing after SaveChangesAsync without an outbox. If the broker is down, the order exists and the event is lost. Use MassTransit's or Wolverine's outbox, or the pattern in the playbook guide on the transactional outbox. Retrying permanent errors. A missing product will fail on every attempt. Mark it as permanent Ignore<T , MoveToErrorQueue, or the permanent check so it reaches the error queue in seconds, not minutes. Idempotency keyed on transport ids. MassTransit MessageId and Wolverine envelope ids change when a client publishes twice. Key the dedupe table on the business identity. Wolverine startup cost and missing handlers. Runtime code generation compiles handlers with Roslyn. For production, pre-generate with dotnet run -- codegen write and set opts.CodeGeneration.TypeLoadMode = TypeLoadMode.Static. If a handler is never called, print opts.DescribeHandlerMatch typeof OrderPlacedHandler . Forgetting the v9 license on build agents. The key must be present wherever MassTransit runs, which includes integration tests on continuous integration agents. Related reading RabbitMQ vs Kafka vs Azure Service Bus for .NET Teams Wolverine for .NET: Messaging and Command Handling in One Library RabbitMQ Dead Letter Exchanges and Delayed Retries with .NET Lost Messages and the Outbox That Fixed Them The Transactional Outbox Pattern in .NET in “The .NET Implementation Playbook”