MediatR and MassTransit Going Commercial: What This Means for You

The free water cooler that started charging

Imagine your school had a water cooler in the hallway. For years, anyone could walk up and drink. It was free. Everyone loved it.

One day a sign appears. The water cooler now has rules. Students can still drink for free. But big offices in the same building, the ones with lots of staff and lots of money, must pay a small monthly fee. The person who fills and cleans the cooler explains why: keeping good water flowing takes real time and money, and they cannot keep doing it for free forever.

Nobody is angry at the water. The water is still good. The question everyone now asks is simple: "Do I have to pay, or do I still drink for free?"

That is exactly what happened to two famous .NET libraries: MediatR and MassTransit. They were free for years. Now they have new rules. This guide explains those rules in plain words, so you know where you stand.

What are these two libraries, in one line each?

Before we talk about money, let us remember what these tools do.

• MediatR is a small library that helps one part of your app talk to another part without them holding tight references to each other. You send a request, and a handler somewhere answers it. People use it a lot for CQRS (splitting commands and queries).
• MassTransit is a bigger library for messaging. It helps different services send messages to each other over a message broker like RabbitMQ or Azure Service Bus. People use it for queues, events, and the saga pattern.

Both were created by respected people in the .NET world. MediatR comes from Jimmy Bogard. MassTransit comes from Chris Patterson. For a long time, both were free and open source.

What actually changed?

Here is the short version. Both projects moved to a commercial license. That means a company now stands behind each one, and bigger users are asked to pay.

• MediatR went commercial in July 2025. It now lives under a company called Lucky Penny Software. (Fun fact: the company is named after a rescued dog named Penny with copper-colored fur.) AutoMapper, another famous library from the same author, moved at the same time.
• MassTransit announced the move with version 9. Version 8 stays free and open source. Version 9, which arrived in early 2026, is commercially licensed.

The important word is dual license. This means each library has two faces:

1. A free edition for small users, learners, and non-profits.
2. A paid edition for bigger companies that make real money from their software.

Why did they do this?

It is fair to ask. These libraries were free for so long. Why charge now?

The honest answer is time and money. Maintaining a popular library is real work. People file bugs. New .NET versions come out every year (.NET 10 is the current LTS, and .NET 11 is in preview). Security issues need fast fixes. Users want help.

When the author had a company sponsoring this work, the time was paid for. When that sponsorship ended and the author went solo, the free hours shrank. A library used by millions cannot rest on a few unpaid evenings.

A commercial license is one way to keep the lights on. The money pays for maintenance, support, and steady updates. In return, big companies get a supported, dependable tool. That is the trade.

A kind way to think about it: you are not paying for the code you already have. You are paying for the future of the code, and for someone to answer when something breaks.

Who still drinks for free?

This is the part most readers care about. Let us be clear and gentle about it.

For MediatR (under Lucky Penny Software), the free Community edition covers:

• Individuals learning or building hobby projects.
• Non-profits and educational use.
• Smaller companies under a revenue limit (the figure quoted is around 5 million US dollars in yearly revenue).
• Non-production use, like local development.

For MassTransit v9, the free tier is aimed at:

• Organizations under a revenue threshold (the figure quoted is around 1 million US dollars per year).
• Local development and evaluation, using a temporary license.

So if you are a student, a solo developer, or a small startup, you very likely still drink for free. The paid rules mostly target larger companies that earn good money from the software they ship.

What does it cost if you do pay?

Prices change over time, so always check the official pages before you decide. But here is a rough picture from the announcements, just so the numbers are not a mystery.

MediatR (Lucky Penny Software) uses tiers based on team size:

MassTransit v9 uses tiers based on company size and revenue:

Treat these as ballpark numbers, not a quote. The real, current prices and exact rules live on the official sites linked at the bottom.

One more friendly detail about MassTransit: a deployed license is tied to the application version and does not stop working at runtime. You only need a current license at the time you deploy a new version. There is no switch that turns your app off mid-flight.

Do I have to upgrade right now? (No.)

This is the most important calm fact in the whole article.

The last free versions are not switched off. MediatR's final free release and MassTransit v8 still work today. They will keep working. There is no secret timer that disables your running app.

So you have time. You do not need to panic-upgrade tonight. You can finish your current project, plan calmly, and decide later. Here are your sensible options.

Option 1: Stay on the last free version

If your app is stable and you do not need new features, staying put is perfectly fine. The code you have is yours to use under the old license. You keep shipping. You just stop getting new updates for that library.

The risk is future you. One day .NET changes enough that the old version feels creaky, or a security fix never comes. So staying is a good short-term plan, not a forever plan.

Option 2: Pay for the license

If your company makes real money from the software, paying is often the smart, honest choice. You get a supported tool and you respect the people who maintain it. For a business, a few thousand dollars a year is small next to the cost of developer time.

A short note for teams: read the license terms with care, because the rules count developers or revenue, not servers. Your finance and legal folks will want the exact words.

Option 3: Switch to a free alternative

You are not trapped. The .NET ecosystem has good free choices.

For a MediatR-style mediator, you can use Wolverine, which also handles messaging. For MassTransit-style messaging, you can look at Rebus, Wolverine, or NServiceBus (note: NServiceBus is also commercial). You can also talk to a broker like Azure Service Bus or Amazon SQS directly with their own SDKs.

Switching costs effort, so weigh it against the license price. Sometimes paying is cheaper than rewriting.

Option 4: Hand-roll a tiny mediator

Here is a secret that surprises many beginners. For simple apps, a "mediator" is not much code. The whole idea is: find the right handler for a request, and call it. You can build a small version yourself.

Let us see how little code it takes. First, the contracts.

// A request that returns a response of type TResponse.
public interface IRequest<TResponse> { }
 
// A handler that knows how to answer one kind of request.
public interface IRequestHandler<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    Task<TResponse> Handle(TRequest request, CancellationToken ct);
}
 
// The mediator: you send a request, it finds and runs the handler.
public interface ISender
{
    Task<TResponse> Send<TResponse>(IRequest<TResponse> request, CancellationToken ct = default);
}

Now a tiny implementation that uses the built-in dependency injection container to find the handler.

public sealed class SimpleSender(IServiceProvider provider) : ISender
{
    public async Task<TResponse> Send<TResponse>(
        IRequest<TResponse> request,
        CancellationToken ct = default)
    {
        // Build the exact handler type for this request at runtime.
        var requestType = request.GetType();
        var handlerType = typeof(IRequestHandler<,>)
            .MakeGenericType(requestType, typeof(TResponse));
 
        // Ask the container for that handler.
        dynamic handler = provider.GetRequiredService(handlerType);
 
        // Call Handle and return the answer.
        return await handler.Handle((dynamic)request, ct);
    }
}

And here is how you would use it, just like the real thing.

// A request and its response.
public record GetGreeting(string Name) : IRequest<string>;
 
// The handler that answers it.
public sealed class GetGreetingHandler : IRequestHandler<GetGreeting, string>
{
    public Task<string> Handle(GetGreeting request, CancellationToken ct)
        => Task.FromResult($"Hello, {request.Name}!");
}
 
// Registration in Program.cs:
builder.Services.AddScoped<ISender, SimpleSender>();
builder.Services.AddScoped<IRequestHandler<GetGreeting, string>, GetGreetingHandler>();
 
// Somewhere in a controller or endpoint:
var greeting = await sender.Send(new GetGreeting("Asha"));

This little mediator is not as powerful as MediatR. It has no pipeline behaviors, no notifications, no fancy features out of the box. But for a small project, it does the core job and costs nothing. Many teams start here and only reach for a bigger library when they truly need more.

A calm checklist before you decide

When the license news first lands, it is easy to feel rushed. Slow down and answer these questions for your own project.

1. Am I in the free tier? If you are a learner, a non-profit, or a small company under the revenue limit, you may not need to do anything.
2. Is my app already shipped and stable? If yes, the last free version keeps working. No rush.
3. Do I need new features or active support? If yes, a paid license is worth a serious look.
4. How much code depends on this library? A little means switching is easy. A lot means switching is costly, and paying might be cheaper.
5. What does my company earn? Be honest. If the software makes good money, paying the maintainers is the fair and grown-up choice.

What this whole episode teaches us

There is a quiet lesson here for every developer, not just .NET ones.

Free open source is wonderful, but it is not magic. Real humans keep it alive, often on their own time. When a library you depend on becomes part of your business, it is healthy to ask: who maintains this, and how do they survive?

It also reminds us to keep our dependencies loose. Notice how easy it was to swap in our own tiny mediator. That was possible because the request and handler ideas are simple and standard. If your code hides a library behind small interfaces, then changing that library later is a calm afternoon, not a frightening month.

Loose coupling is not just clean design. It is insurance against the day a tool you love changes its rules.

References and further reading

• MediatR and MassTransit Going Commercial: What This Means for You (Milan Jovanovic)
• AutoMapper and MediatR Commercial Editions Launch Today (Jimmy Bogard)
• AutoMapper and MediatR Licensing Update (Jimmy Bogard)
• Announcing MassTransit v9 (official docs)
• Lucky Penny Software Licensing FAQ
• MediatR on GitHub (LuckyPennySoftware)

Quick recap

• MediatR went commercial in July 2025 under Lucky Penny Software. MassTransit v9 went commercial in early 2026; v8 stays free.
• Both use a dual license: a free tier for learners, non-profits, and small companies, plus a paid tier for bigger businesses.
• Free tiers are generous. Most students, hobbyists, and small teams still pay nothing.
• The last free versions keep working. There is no runtime kill switch, so you do not need to panic-upgrade.
• Your options are calm: stay on the free version, pay for support, switch to a free alternative (Wolverine, Rebus), or hand-roll a tiny mediator.
• The big lesson: keep dependencies loose so swapping a library later is easy, and remember that real people keep open source alive.