---
title: "Apache Artemis™ vs. Apache ActiveMQ® Classic vs. RabbitMQ®: Inside meshIQ’s 2026 Messaging Broker Benchmark"
date: 2026-11-18
author: "TheFrameGuy"
featured_image: "https://www.meshiq.com/wp-content/uploads/blog-artemis-vs-activemq-vs-rabbitmq-111826.jpg"
categories:
  - name: "Apache ActiveMQ®"
    url: "/sort-by/active-mq.md"
  - name: "meshIQ"
    url: "/sort-by/meshiq.md"
  - name: "Messaging"
    url: "/sort-by/messaging.md"
  - name: "Middleware"
    url: "/sort-by/middleware.md"
  - name: "Monitoring"
    url: "/sort-by/monitoring.md"
  - name: "RabbitMQ"
    url: "/sort-by/rabbitmq.md"
---

# Apache Artemis™ vs. Apache ActiveMQ® Classic vs. RabbitMQ®: Inside meshIQ’s 2026 Messaging Broker Benchmark

meshIQ’s new research report compares three widely used open-source messaging brokers across workload shapes, durability requirements, concurrency levels, messaging patterns, and protocols, including JMS, native clients, and AMQP 1.0. In a two-part podcast, host **Mike Jauquet** sat down with two guests to unpack the results:

- **Dan Rigos**, DevOps engineer at meshIQ, who designed and ran the tests
- **JB Onofré** of the Apache Software Foundation, who works on Apache ActiveMQ® and Apache Artemis™

Here is their conversation, edited for length and clarity.

## Key takeaways

- **There is no universal winner.** Apache Artemis™, Apache ActiveMQ® Classic and RabbitMQ® each lead in different scenarios.
- **Apache Artemis™ leads on small-message, durable JMS workloads**, thanks to its append-only journal and lightweight JMS layer.
- **Apache ActiveMQ® Classic is limited by disk commits, not messages.** It hit about 400 commits per second with one message per commit, and nearly 35,000 messages per second with batching.
- **RabbitMQ®’s client choice matters enormously.** Request-reply latency was about 105 ms through the JMS client and about 1.2 ms through the native client.
- **AMQP 1.0 changes the leaderboard.** RabbitMQ® 4, with native AMQP 1.0 support, won every single-message test on that track.
- **Benchmarks are a starting point.** The same broker can be 80 times faster or slower depending on client and configuration.

## Why did meshIQ revisit its messaging broker benchmark?

**Mike Jauquet:** Before we get into latency and throughput, let’s start with why. Dan, what gap in the market made this report worth doing now?

**Dan Rigos:** It started with a question we hear more and more in the field: “We’re tied up with proprietary software X. What are our options for moving away from it, maybe to open source options like Y or Z?” What drives that varies. It might be cost, return on investment or future-proofing. At the same time, open source messaging platforms keep emerging, along with commercial offerings built around them. We felt it was our due diligence to research and test these technologies and offer guidance to anyone asking that question.

**Mike Jauquet:** This isn’t meshIQ’s first benchmark. The 2022 report covered seven brokers. This one narrows to three: Apache Artemis™, Apache ActiveMQ® Classic and RabbitMQ®. Why go narrower and deeper?

**Dan Rigos:** Looking back, the 2022 report had a huge number of tests and parameters, but it lacked a cohesive direction. In retrospect, it felt like an ocean with the depth of a puddle. This time, we built everything around one idea we treated as unbreakable: every message a producer sends must be consumed and acknowledged by a consumer. Guaranteed end-to-end delivery, with zero message loss. We chose these three brokers because they’re open source, and because more and more enterprises are switching to them or seriously considering it.

## What did the experts expect, and what surprised them?

**Mike Jauquet:** JB, you’ve had a chance to review the findings. What confirmed your expectations, and what surprised you?

**JB Onofré:** First, I was impressed by how careful the procedure was. Benchmarking is not easy, and comparing different systems requires a clear path. You can tell the work took months, because even the names changed along the way. The report uses “Apache ActiveMQ® Classic,” but the projects are now simply Apache ActiveMQ® and Apache Artemis™.

Some results confirmed what we know. Apache Artemis™ dominating small-message durable JMS was no surprise; it comes from Apache Artemis™’s design. Apache ActiveMQ® with a batch size of one being at the mercy of disk latency was also well known. But two things surprised me. RabbitMQ® used to handle AMQP 1.0 through a plugin that I thought of as slow and secondary. Since RabbitMQ® 4, AMQP 1.0 is native, and RabbitMQ® outperformed Apache Artemis™ and Apache ActiveMQ® on that track. The report updated my picture of the state of the art. The second, less surprising, was that request-reply over JMS on RabbitMQ® was weaker, because JMS isn’t a first-class citizen there.

**Dan Rigos:** My two notes were the same, which is funny. The first was me kicking myself for missing how well Apache ActiveMQ® handles batching. In 2022, I don’t believe I was batching properly, so the throughput we saw was really just the disk limit. The Apache ActiveMQ® docs say very clearly: if you’re handling large throughput, use batching. The second was the penalty of using the JMS client on RabbitMQ®, which I’ll explain later. Overall, every technology here has its play. You can’t read this report and say, “I’m definitely not going with that one.”

## What does guaranteed delivery mean in a benchmark?

**Mike Jauquet:** The report treats guaranteed delivery as a hard constraint, not something measured alongside performance. JB, what had to be true for a result to count?

**JB Onofré:** It’s what every user expects. If a persistent message can’t survive a power outage or network failure, that’s a huge issue. At a high level, there are two components. The first is persistence, how the broker stores messages. Apache ActiveMQ® acknowledges the producer only once the message is synced to disk. Apache Artemis™ also uses the disk but leverages lower-level APIs, such as asynchronous I/O on Linux. RabbitMQ® is similar to Apache ActiveMQ® for persistence, but confirms publishers asynchronously. The second is reconciliation: how the broker reloads messages and deals with duplicates. Apache ActiveMQ® keeps acknowledgments and disk state in sync, which is very safe. Apache Artemis™ and RabbitMQ® use different reconciliation approaches to boost performance. What the report shows is that all three are rock solid on guaranteed delivery. They just get there differently.

## Why test JMS, native protocols and AMQP 1.0?

**Mike Jauquet:** Dan, you tested every broker across three protocol tracks. Why that structure?

**Dan Rigos:** Parity. We wanted a fair playing field. Track A is the JMS specification, because many enterprises still run business-critical workflows on JMS, and every broker here supports it, though each handles it differently. The native protocol track and the AMQP 1.0 track grew out of that. Someone interested in RabbitMQ® may not care about JMS at all. They’ll use RabbitMQ®’s native protocol, or AMQP 1.0 on RabbitMQ® 4. Or an enterprise may need AMQP 1.0 for an upstream or downstream service. We wanted to show their options.

## Why does Apache Artemis™ lead on small-message JMS workloads?

**Mike Jauquet:** Let’s get into the numbers, starting with Apache Artemis™. JB, what did the data show for small-message, high-concurrency JMS, and what’s happening architecturally?

**JB Onofré:** Two things. First, the journal. Apache Artemis™ appends records to the end of its persistent store, similar to Kafka. You never rewrite files; you just keep appending, so small messages are very fast to persist, especially with asynchronous I/O on Linux, where you can run a huge number of operations in parallel. Second, Apache Artemis™ uses a thin JMS wrapper directly on top of its core engine. Every connection is very light for the client and, more interestingly, for the broker. The smaller the message, the faster it goes into the journal. It’s as simple as that.

## Apache ActiveMQ® Classic: why commits per second are not messages per second?

**Mike Jauquet:** Classic tells a different story. A hard ceiling around 400 commits per second in the strictest durability setting, but nearly 35,000 messages per second once you introduce batching. JB, what’s the difference between a commit and a message here?

**JB Onofré:** With a batch of one, Apache ActiveMQ® hits the limit of your disk quickly, because it’s one message to one disk write. Apache ActiveMQ® stores messages in KahaDB, a journal-based store, and every commit runs an fsync call. By design, fsync doesn’t parallelize across storage queues, so with lots of concurrent producers you get contention on the file system. When you batch, you group a set of messages into one JMS transaction, so one I/O operation stores the whole group. That’s why, with batching, Apache ActiveMQ® actually did better than the other two brokers.

What I tell users often is that the broker is one thing, but the client logic is very important for Apache ActiveMQ®. Don’t expect the broker to do everything. Write your applications to use the Apache ActiveMQ® JMS client the most efficient way.

## Why is RabbitMQ® request-reply 105 ms over JMS but 1.2 ms native?

**Mike Jauquet:** Dan, RabbitMQ® had one of the most striking numbers: request-reply latency around 105 milliseconds over the JMS client, dropping to about 1.2 milliseconds on the native client. What’s behind that?

**Dan Rigos:** The 105 ms is jarring next to everything else, but it can be explained. The RabbitMQ® JMS library implements a timed receive as a basic get that polls with a fixed 100-millisecond back-off. Every round trip is subject to that polling interval, which is why the number doesn’t move when you change payload size or the number of producers and consumers. It’s similar to the disk ceiling on Apache ActiveMQ®: capped by something other than the broker’s real performance. With the native client as a push consumer, the reply arrives almost as soon as it’s routed. That’s the real cost, about 1.2 ms, still meeting guaranteed delivery. There may also be a polling setting I missed, which we can look at in a revision.

**Mike Jauquet:** So “RabbitMQ® latency is X” doesn’t mean much without asking which client and which protocol.

## How does pub/sub fan-out scale on each broker?

**Mike Jauquet:** JB, pub/sub fan-out scaled very differently as you added subscribers. What does that reveal?

**JB Onofré:** You have to look under the hood. Apache Artemis™ decouples addresses and queues. When a message is published, the payload is stored once, and the broker manages lightweight delivery pointers for each subscriber. It’s a nice design. Apache ActiveMQ® manages durable subscriptions directly in KahaDB, which is why it scaled best in regular JMS mode. Apache ActiveMQ® also has virtual topics. Normally, the JMS spec limits concurrent consumption for a single subscriber on a topic. Virtual topics create a physical queue per subscriber, so you get concurrent consumption and a real performance boost. RabbitMQ® is more of a broker-side challenge. Each durable subscriber maps to its own queue, each running its own Erlang process with its own disk sync. Without group commits across queues, publisher confirms wait until every subscriber queue has written to disk, so the publisher looks slow.

## Why does AMQP 1.0 flip the leaderboard?

**Mike Jauquet:** When all three brokers speak AMQP 1.0, the rankings change. JB, what happened on that track?

**JB Onofré:** On the JMS track, Apache Artemis™ dominated small messages. On the AMQP 1.0 track, RabbitMQ® won every test with a batch size of one, because AMQP is at the core of the broker and it can confirm each message efficiently. Apache ActiveMQ®, which batching boosted enormously on JMS, stayed flat on AMQP whatever the batch size. That’s because this track measured non-transactional AMQP 1.0, where durability is enforced per message, not per batch, and Apache ActiveMQ® doesn’t support group commit for AMQP. That could be a good improvement for Apache ActiveMQ®. To be honest, though, I don’t see many Apache ActiveMQ® users on AMQP today.

**Dan Rigos:** RabbitMQ® doesn’t use transactions on this track, so for parity I didn’t use them for the others either. That explains why Apache ActiveMQ® didn’t get the same batching benefit there.

## How did the team keep the benchmark data honest?

**Mike Jauquet:** One thing I appreciate is that the report doesn’t pretend benchmarking is clean. Dan, you caught and corrected an issue where some Apache Artemis™ AMQP 1.0 numbers were inflated by a Netty allocator artifact. How did that come to light?

**Dan Rigos:** It was a compounding issue. The fix for the original bug exposed another one, and a unit change was adding to it. Once we converted to messages per second, we were claiming up to 4 GB per second written to a disk whose specification maxes out well under 1 GB per second. That created a rule for the whole report: if a result doesn’t make sense, find the root cause. Sometimes that meant changing how producers, consumers or connections worked. Sometimes it was as simple as getting a unit conversion right.

**Mike Jauquet:** In another case, you didn’t publish the results at all. A RabbitMQ® run failed your reconciliation check. What does that check do?

**Dan Rigos:** Every trial counts messages at the start and end. Did every message produced come out the other side, once per subscriber? Our first RabbitMQ® pub/sub run on AMQP 1.0, with two subscribers, came back with exactly half the expected count. The address format we were using made RabbitMQ® load-balance across the subscribers instead of fanning out. In production, you might want that. For our test, it wasn’t the case, so the check threw those runs out automatically. We fixed the setup, reran it and reported those numbers in a separate section. When messages produced don’t match messages consumed, that’s an immediate red flag, and every one of those deep dives taught us something new about how the brokers work.

## What should teams monitor once a broker is in production?

**Mike Jauquet:** Choosing a broker is day one. The harder question is day 200 or day 2,000, when something starts to slow down or back up. Dan, how do the findings connect to day-two operations?

**Dan Rigos:** Everything we hit during testing, including fsync ceilings, full stores, direct memory leaks and silent fan-out bugs, can and does happen in production, especially at scale. The monitoring lesson is to watch:

- Disk sync latency
- Store usage
- Direct memory
- Consumer lag
- End-to-end message counts

Those checks catch problems that traditional dashboards or management planes might miss. Tools like the meshIQ platform can help bridge that gap, monitoring and managing message brokers whichever technology you choose, including the ones in this report and beyond.

## Why is the industry converging on AMQP 1.0?

**Mike Jauquet:** JB, this report treats AMQP 1.0 as a first-class protocol on every broker, which the 2022 report didn’t. What’s driving that shift?

**JB Onofré:** It’s the protocol itself. AMQP 0-9-1 assumed the broker topology, the exchanges and bindings, in the wire protocol, which was a barrier to adoption. AMQP 1.0 is a true symmetric, wire-level transport protocol. It standardizes framing, flow control, security and transactions on the wire. The big benefit for the industry is breaking vendor and client lock-in. In the past, application code used proprietary client libraries, so changing brokers meant changing clients. With AMQP 1.0, your microservices, whether they’re written in Java, Python, Go or Rust, only know the protocol, not the broker behind it.

## How should teams use the benchmark report?

**Mike Jauquet:** Let’s make this practical. Dan, for someone choosing between these brokers, or between JMS, native and AMQP 1.0, how should they read the data?

**Dan Rigos:** This report wasn’t made to put anyone on a podium and hand out medals. It’s a stepping stone. Find the row or test case that looks like a small sample of your day-to-day workload, and treat it as a hypothesis for your own environment. The same broker can be 80 times faster or slower depending on the client and configuration, not to mention the infrastructure underneath. With faster SSDs, for example, you may get past the disk limits we hit. There are also intangibles the report doesn’t measure: commercial support, commercial redistributions and the active development and trajectory of each project. Use it as one step of many.

## What should teams already running these brokers check this week?

**Mike Jauquet:** Plenty of listeners already run Apache Artemis™, Apache ActiveMQ® or RabbitMQ® in production. What’s the one finding that should send them to check their configuration?

**Dan Rigos:** Look at how your Apache ActiveMQ® is configured. If you’re writing persistent messages to KahaDB in very high-throughput workloads, you could be bottlenecked waiting for disk write confirmations. And batching is close to non-negotiable for large enterprise workloads on Classic.

**JB Onofré:** Something I hear a lot is, “My Apache ActiveMQ® broker doesn’t scale.” That’s normal if you’re using the default configuration, and the same goes for Apache Artemis™. Start by understanding your use case: the number of clients and concurrent connections, the transports you use, whether it’s only AMQP or a mix with JMS, OpenWire and MQTT, your message sizes, and above all, whether you need persistent messages at all. Then decide on producer flow control, cursors and prefetch size. My advice is to draw a picture on paper of all your brokers, clients and connections. Once you have the overall picture, the tuning is pretty easy to find.

## What’s next for the research?

**Mike Jauquet:** What didn’t make it into this revision, and what are you thinking about for the next one?

**JB Onofré:** I’m a big fan of multi-node brokers. High availability, replication and failover, Apache ActiveMQ®’s network of brokers and newer mechanisms in Apache Artemis™ like mirroring. Measuring the impact of scaling would be great.

**Dan Rigos:** Every test this time ran on a standalone broker. Next, I’d like to scale out, with quorum queues on RabbitMQ®, broker pairs and high availability in general. I’d also like to reintroduce non-persistent, fire-and-forget tests, and maybe compare commercially supported offerings with the standalone open source versions.

**Mike Jauquet:** My biggest takeaway is that there isn’t a single number that tells you which message broker is best. Apache Artemis™, Apache ActiveMQ® Classic and RabbitMQ® each behave differently depending on workload, message pattern, durability, client and protocol. That’s the value of this research: it helps architects, developers and platform teams move beyond assumptions. And once a broker is part of critical production, teams also need the visibility and discipline to understand what’s happening, when performance changes and why.

### Frequently Asked Questions

Which is faster, Apache Artemis™, Apache ActiveMQ® Classic or RabbitMQ®?

It depends on the workload. In meshIQ’s 2026 benchmark, Apache Artemis™ led small-message durable JMS tests, Apache ActiveMQ® Classic led batched JMS throughput at nearly 35,000 messages per second, and RabbitMQ® led single-message AMQP 1.0 tests.







Why is Apache ActiveMQ® Classic slow without batching?

With one message per commit, every commit triggers an fsync to KahaDB, so throughput is capped by disk sync speed, about 400 commits per second in the test environment. Batching messages into one JMS transaction removes that bottleneck.







Why is RabbitMQ® request-reply slower with JMS?

The RabbitMQ® JMS client implements timed receives as polling with a 100 ms back-off. In the benchmark, request-reply latency was about 105 ms with the JMS client and about 1.2 ms with the native client.







Does AMQP 1.0 perform well on RabbitMQ®?

Yes. Since RabbitMQ® 4 supports AMQP 1.0 natively, RabbitMQ® won every single-message test on the AMQP 1.0 track.







What should I monitor on a production message broker?

Disk sync latency, store usage, direct memory, consumer lag and end-to-end message counts.













### Read the full report

The report covers every test, configuration and result discussed here. [Download meshIQ’s 2026 open-source messaging broker benchmark report](https://www.meshiq.com/research-assets/multi-protocol-performance-benchmarks-2026/) and [listen to the full two-part podcast](https://www.meshiq.com/podcast/) with Dan Rigos and JB Onofré.