Apache Kafka vs RabbitMQ vs Redpanda: Streaming Pricing at 10M, 100M and 1B Messages
Picking a streaming platform is a pricing decision wearing an architecture costume. Kafka, RabbitMQ and Redpanda all move messages between services. At production volume they charge in different units — metered compute plus per-GB movement, flat monthly rent, or hourly broker rent — and the cheapest at 10 million messages a month is rarely the cheapest at 1 billion. This playbook prices the three at three stated profiles, with every line of arithmetic shown.
> [!KEY TAKEAWAY]
> At every profile here, the bill is dominated by a fixed floor — Confluent's eCKU charge, CloudAMQP's flat rent, or MSK's broker hours — not by the per-GB meter. The per-million cost falls roughly 75-fold between 10 million and 1 billion messages.
What each platform is
Apache Kafka is a distributed, partitioned, replicated commit log. Producers append events to topics; consumers read from any position they choose and remember that position themselves. Records disappear only when a retention rule says they are old enough. Per the Apache Kafka 4.4 introduction, events with the same key land in the same partition, and a consumer of that partition always reads them in the order written. That log shape suits event sourcing and stream processing — and it is the wrong tool when you want a message consumed exactly once and then gone.
RabbitMQ is a message broker built around routing. A producer publishes to an exchange, the exchange routes the message to one or more queues through bindings, and a consumer takes the message off a queue and acknowledges it. One publish can fan out to many queues. Classic queues delete a message once consumed. RabbitMQ 4.4 adds quorum queues, a durable, Raft-replicated queue type the RabbitMQ docs call the default choice for a replicated, highly available queue; and streams, an append-only log that can be read repeatedly until messages expire, with replay from any offset. RabbitMQ fits work that must be routed, acknowledged and removed.
Redpanda is a Kafka-compatible streaming platform written in C++ with no ZooKeeper and no JVM. It speaks Kafka's protocol, so existing Kafka clients and the standard Kafka SDK work against it unchanged, with the same API calls and JSON payloads. Redpanda sells managed Serverless, Bring Your Own Cloud, and self-managed Enterprise Edition. If your team already runs Kafka clients and wants lower operational weight without rewriting producers, Redpanda is a drop-in candidate. If your team has no Kafka code at all, its compatibility buys nothing.
The managed versus self-managed boundary
Managed means the vendor runs the brokers, the patching and the 03:00 page. Self-managed means your team does, inside your own VPC. A managed Kafka service still leaves you owning partition design and consumer-group lag. The question is who owns broker upgrades, disk-full incidents and replication repair. At small volume the floor is the whole story: Confluent Standard starts at about $385 a month before a single message moves, three MSK brokers cost $446.76 a month at 730 hours before storage, and a dedicated CloudAMQP broker costs $99 a month.
> [!FOUNDER]
> "Founders do not pick a streaming platform, they pick a failure they can afford. Work out which failure would close your business for a day, then buy the platform whose price prevents that one."
> — Enow A. Jovial, Founder & Chief Executive Officer
The three throughput profiles
Assumptions for every figure below: average message size 1 KB; a month is 730 hours; retention is modelled at 7 days; Confluent data counts ingress plus one full egress read; the eCKU line assumes 1 eCKU at 70 percent utilisation.
| Profile | Messages/month | Ingress volume | Average rate |
|---|---:|---:|---:|
| Starter | 10,000,000 | 10 GB | 3.8 msgs/s |
| Growth | 100,000,000 | 100 GB | 38.0 msgs/s |
| Scale | 1,000,000,000 | 1,000 GB | 380.3 msgs/s |
Confluent Cloud: metered Kafka, priced three ways at once
Confluent Cloud bills three meters at once: eCKUs per hour, data in and out per GB, and storage per GB-month. Rates below were read from the Confluent pricing page on 2026-11-06.
| Tier | eCKU ($/hour) | Data ($/GB) | Storage ($/GB-month) | SLA | Ingress / egress |
|---|---|---|---|---|---|
| Basic | First free, then $0.14 | $0.05 | $0.08 | 99.5% | 250 / 750 MBps |
| Standard | $0.75 | $0.035–$0.050 | $0.08 | 99.9–99.99% | 250 / 750 MBps |
| Enterprise | $1.75–$2.25 | $0.020–$0.050 | $0.08 | 99.9–99.99% | 1,920 / 5,760 MBps |
| Freight | $2.25 (min 2) | $0.014–$0.030 | $0.03 | 99.99% | 9,120 / 27,360 MBps |
The eCKU line is the same at every profile, which is the point. One Standard eCKU at 70 percent utilisation costs 1 x $0.75 x 730 x 0.70 = $383.25 a month, matching Confluent's published starting cost of about $385; Enterprise at the low end is 1 x $1.75 x 730 x 0.70 = $894.25, matching about $895.
At Starter, 20 GB moved costs 20 x $0.05 = $1.00 and 2.33 GB retained costs 2.33 x $0.08 = $0.19. At Growth: $10.00 and $1.87. At Scale: $100.00 and $18.67. Totals:
$
\text{Standard 10M} = \$383.25 + \$1.00 + \$0.19 = \$384.44/\text{month}
$
$
\text{Standard 100M} = \$383.25 + \$10.00 + \$1.87 = \$395.12/\text{month}
$
$
\text{Standard 1B} = \$383.25 + \$100.00 + \$18.67 = \$501.92/\text{month}
$
Enterprise at the low end totals $894.84, $900.12 and $952.92 at the three profiles. Basic, with its first eCKU free, totals $1.19, $11.87 and $118.67 — cheapest at every volume, but its SLA is 99.5 percent, storage caps at 5 TB, and it has no audit logs.
> [!WARNING]
> Basic's free eCKU is a trap for production workloads. A 99.5 percent SLA allows about 3 hours 39 minutes of downtime a month, and there are no audit logs. If the stream carries money — payments, orders, B2B settlement events — the $383.25 Standard floor is the cheapest honest price.
CloudAMQP: flat rent for RabbitMQ
CloudAMQP does not meter messages on dedicated plans. It rents a broker by the month, flat. The dedicated RabbitMQ prices below were read from the CloudAMQP plans page on 2026-11-06. Sassy Squirrel is $50 a month (5,000 messages per second in burst, 500 connections), Big Bunny $99 (10,000 per second, 1,000 connections), Happy Hare $199 (12,000 per second, 8,000 connections), rising to Raging Rhino at $5,499. The page labels the burst figures "Benchmarked"; treat them as vendor-published ceilings, not as results from our own testing.
Big Bunny at $99 a month covers all three profiles: even Scale averages 380 messages per second against a 10,000-per-second burst ceiling:
$
\text{CloudAMQP dedicated 10M / 100M / 1B} = \$99.00/\text{month (flat)}
$
Shared plans carry quotas: Little Lemur is free with a 1 million-message monthly quota; Tough Tiger is $19 a month with a 10 million-message quota, covering Starter exactly at its quota edge and nothing above it. Extra storage costs $0.35 per GB per month, data transfer is included within a fair-use allowance of 30 percent of monthly spend, and a three-node multi-AZ cluster costs three times the single-node rent. See the sibling comparison at Confluent Cloud vs CloudAMQP vs AWS SQS.
AWS MSK: self-managed Kafka by the broker-hour
AWS MSK Provisioned rents brokers by the hour and storage by the GB-month; your team runs the topics. The figures below come from AWS's own worked pricing arithmetic on the MSK pricing page, read on 2026-11-06. Three kafka.m7g.large Standard brokers at $0.204 an hour cost 2,232 x $0.204 = $455.33 a month in AWS’s 31-day worked example; storage at $0.10 per GB-month came to $151.61 for 1,516.13 GB-months, for a total of $606.94 — a workload ingesting 100 KB per second with 24-hour retention and a replication factor of 2. Express brokers cost $910.66 for three msk.m7g.large at $0.408 an hour, plus $0.01 per GB ingested and $0.10 per GB-month stored, totalling $1,020.66.
Modelled the same way at 730 hours — three Standard m7g.large brokers, 500 GB of provisioned storage, about $5 of transfer — MSK costs $446.76 + $50.00 + $5.00 = $501.76 a month at every profile:
$
\text{MSK Standard} = \$446.76 + \$50.00 + \$5.00 = \$501.76/\text{month (flat)}
$
MSK beats Confluent Enterprise at every profile and ties Confluent Standard at Scale, but the $510.33 buys no operations: upgrades, rebalancing, disk-full incidents and replication repair are your team's work, inside your own VPC, on your own pager. MSK Serverless rates were not extracted this cycle, so no Serverless total is quoted here.
Redpanda Cloud: quote-only, and why that is the honest answer
Redpanda's pricing page, read on 2026-11-06, publishes no per-GB, per-hour or per-node dollar rate. Serverless is pay as you go with no rate shown; Bring Your Own Cloud is an annual commitment with a 14-day trial; Enterprise Edition is contact-us. No monthly total is given for Redpanda, and no estimate was invented to fill the gap.
Serverless runs multi-tenant on AWS and GCP with 100 MB/s maximum write, 300 MB/s maximum read, 5,000 partitions and a 99.9 percent SLA. Bring Your Own Cloud runs fully managed clusters inside your own VPC with 2 GB/s maximum write, 4 GB/s maximum read, 112,500 partitions and a 99.99 percent SLA, plus intelligent tiered storage and Apache Iceberg topics. Each free-trial customer qualifies for $100 in credits to spend in the first 30 days, with no credit card required.
Cost per million messages
Divide each monthly total by the profile's message count in millions:
| Platform / tier | 10M msgs | 100M msgs | 1B msgs |
|---|---:|---:|---:|
| Confluent Basic | $0.12 | $0.12 | $0.12 |
| Confluent Standard | $38.44 | $3.95 | $0.50 |
| Confluent Enterprise | $89.48 | $9.00 | $0.95 |
| CloudAMQP Big Bunny (dedicated) | $9.90 | $0.99 | $0.099 |
| AWS MSK Standard (3 brokers) | $50.18 | $5.02 | $0.50 |
| Redpanda Cloud | quote-only | quote-only | quote-only |
Every per-million cost falls by roughly two orders of magnitude between Starter and Scale. At Scale the field compresses — Standard $0.50, MSK $0.50, Big Bunny $0.099 — and the decision stops being about price and starts being about semantics. Before committing, run the same profiles through the pricing calculator with your SaaS margins.
> [!TIP]
> Price the burst, not the average: a flash sale or retry storm can sustain ten times the Scale average of 380 messages per second for minutes. Check the burst ceiling against your worst ten minutes.
Retention and ordering guarantees
Kafka retains all published messages, whether or not they have been consumed, for a configurable period — set a two-day retention and a message is available for two days, then discarded. A consumer group can rewind and replay history, which justifies Kafka's premium over a plain queue. Configure that window with `retention.ms` per topic. RabbitMQ classic queues delete a message once consumed; Little Lemur caps queued messages at 10,000 with a 28-day idle queue time, Tough Tiger at 100,000. RabbitMQ streams model an append-only log, readable repeatedly until messages expire, with retention set by `x-max-length-bytes` or `x-max-age`.
Kafka orders strictly within a partition and offers no total order across partitions; the key decides the partition, so the key decides the ordering guarantee. RabbitMQ orders within a single queue with one consumer; competing consumers break strict ordering, and streams add log ordering with replay from a chosen `x-stream-offset`. The in-memory comparison at Redis vs Memcached vs Valkey covers the same single-key discipline for caches.
Throughput ceilings
Confluent Basic and Standard top out at 250 MBps ingress and 750 MBps egress, Enterprise at 1,920 / 5,760 MBps, Freight at 9,120 / 27,360 MBps. Partition limits are 1,500 on Basic, 2,500 on Standard, 96,000 on Enterprise and 50,000 on Freight; a topic design that needs 3,000 partitions cannot live on Standard at any price. CloudAMQP's ladder runs from 5,000 messages per second in burst to the Raging Rhino tier, with connections from 500 to 400,000; the binding constraint is usually connections or queues, not raw message rate. Redpanda Serverless caps at 100 MB/s write, 300 MB/s read and 5,000 partitions; BYOC raises those to 2 GB/s write, 4 GB/s read and 112,500 partitions. Measure your peak in megabytes per second and in partitions.
Decision table
| Situation | Pick | Authority |
|---|---|---|
| Event sourcing, replay, stream processing | Confluent Standard or Enterprise | Kafka log semantics (Apache Kafka introduction, 4.4) |
| Task routing, fan-out, ack-and-delete work | CloudAMQP dedicated RabbitMQ | Exchange-to-queue routing (RabbitMQ docs, 4.4) |
| Replay needed without adopting Kafka operations | RabbitMQ streams on CloudAMQP | Append-only log, offset replay (RabbitMQ streams docs) |
| Kafka clients already written, lower ops wanted | Redpanda Cloud (trial first) | Kafka compatibility, published ceilings (Redpanda pricing) |
| Kafka on AWS with your team owning operations | AWS MSK Provisioned | Vendor arithmetic: 3x m7g.large $606.94 (AWS MSK pricing) |
| Hobby or prototype under 10M messages | CloudAMQP Tough Tiger or Confluent Basic | $19 quota plan / free first eCKU (vendor pricing pages) |
Who should NOT pick each platform
Do not pick Kafka — managed or self-managed — for simple task routing with acknowledgement and deletion; a queue would have done the job in a week. Do not pick RabbitMQ classic queues when the business needs replay: a consumed message is gone; use streams or Kafka instead. Do not pick Redpanda on price alone until the vendor quotes against your measured usage; a sales-led quote can land above Confluent Standard for the same volume. Do not pick MSK when nobody on the team has run Kafka before. Do not pick Confluent Basic for anything carrying money: 99.5 percent uptime and no audit logs are development terms. And do not pick any platform on per-million cost alone: the floor dominates and flatters the cheapest floor, not the best fit.
Execution checklist
1. Write the workload in one sentence: task routing, event sourcing, or log ingestion.
2. Measure real message sizes from production logs, not the 1 KB assumption here.
3. List every consumer group's ordering requirement, then assign partition keys or queue names.
4. Set retention from the business need and price storage from that number.
5. Check the burst ceiling for the worst ten minutes.
6. Price Confluent from the eCKU floor, CloudAMQP from the flat rent, MSK from broker hours plus storage.
7. For Redpanda, run the $100 Serverless trial on real producers, export usage as CSV, and get a written quote against measured usage.
8. Confirm each tier's SLA before committing.
9. Verify TLS in transit, encryption at rest, and Kafka ACLs on every topic and queue.
10. Deploy to staging, replay a full day of production traffic, and confirm lag returns to zero before cutover.