---
title: Amazon MQ Pricing: $500+/Month Before Your First Message
description: Amazon MQ bills per broker instance hour: an mq.m5.large ActiveMQ active/standby pair is ~$420/month before storage. Add EFS storage, data transfer, and monitoring and a production HA deployment lands at $510 to $560/month, or $720 to $770 for a three-node RabbitMQ cluster, with zero messages flowing. Use MQ only when AMQP, JMS, STOMP, MQTT, or OpenWire protocol compatibility is non-negotiable.
url: https://www.joinhorizon.co/blog/amazon-mq-pricing-broker-instance-storage-throughput/
datePublished: 2026-06-13T00:00:00.000Z
dateModified: 2026-10-28T00:00:00.000Z
author: kevin-w
category: Cost Optimization & FinOps
tags: amazon-mq, mq-pricing, aws-pricing, cost-optimization, finops, messaging
---

# Amazon MQ Pricing: $500+/Month Before Your First Message

> Amazon MQ bills per broker instance hour: an mq.m5.large ActiveMQ active/standby pair is ~$420/month before storage. Add EFS storage, data transfer, and monitoring and a production HA deployment lands at $510 to $560/month, or $720 to $770 for a three-node RabbitMQ cluster, with zero messages flowing. Use MQ only when AMQP, JMS, STOMP, MQTT, or OpenWire protocol compatibility is non-negotiable.

import PricingHeroStats from '~/components/blog/PricingHeroStats.astro';
import PricingDimensionTable from '~/components/blog/PricingDimensionTable.astro';
import BillSurpriseCallout from '~/components/blog/BillSurpriseCallout.astro';
import PricingDecisionCard from '~/components/blog/PricingDecisionCard.astro';

Amazon MQ is the AWS-managed message broker service running either ActiveMQ or RabbitMQ. It is the most expensive entry point in the AWS messaging family by a wide margin. Production-grade deployments start at roughly $500 to $750/month before a single message moves. The premium pays for protocol compatibility with AMQP, JMS, STOMP, MQTT, and OpenWire, protocols that SQS and SNS do not support. For applications that can speak the AWS-native messaging API, MQ is dramatically more expensive than the equivalent SQS setup; for applications locked to the broker protocols, MQ is the only managed option short of running your own broker on EC2.

> **Amazon MQ pricing** bills broker instance hours, storage, and data transfer, with a high minimum entry point compared to SQS/SNS. In us-east-1 (June 2026), a single mq.t3.micro dev broker runs about $20/month, while a production mq.m5.large active/standby HA pair is about $420/month before storage. Most surprises come from running MQ for workloads that only need JMS semantics occasionally, not continuously.

| Broker              | Approx. monthly    | When justified         |
| ------------------- | ------------------ | ---------------------- |
| mq.t3.micro         | ~$20 single        | Dev or legacy JMS test |
| mq.m5.large         | ~$210/broker       | Single-broker prod     |
| Cluster (3 brokers) | ~$630 (3× single)  | HA throughput need     |
| SQS alternative     | Pennies/M requests | New event-driven apps  |

<PricingHeroStats
  stats={[
    { value: '$510+', label: 'Min production / month', note: 'ActiveMQ HA + storage; zero messages' },
    { value: '$0.288/hr', label: 'mq.m5.large single-AZ', note: 'Doubles for active/standby HA' },
    { value: '$0.30 vs $0.10', label: 'EFS vs EBS / GB-month', note: 'ActiveMQ vs RabbitMQ storage' },
    { value: '3 brokers', label: 'RabbitMQ cluster mode', note: '3× a single broker; 1.5× an active/standby pair' },
  ]}
  caption="us-east-1 list prices, June 2026. Verify against the AWS MQ pricing page for your region. Source: [AWS Pricing page](https://aws.amazon.com/amazon-mq/pricing/), us-east-1, retrieved June 2026."
/>

This post is the bill story. For the broader messaging-architecture decision (when MQ vs SQS vs SNS vs EventBridge vs Kafka), our [reliable queue systems on AWS post](https://www.joinhorizon.co/blog/reliable-queue-systems-aws-sqs-kafka-redis/) covers the trade-offs.

## The MQ billing dimensions

<PricingDimensionTable
  title="Amazon MQ pricing breakdown, us-east-1, June 2026"
  intro="Broker instance hours dominate. Storage and data transfer are smaller but compound at production scale."
  region="us-east-1"
  dimensions={[
    {
      name: 'mq.t3.micro single-AZ',
      unitPrice: '$0.027 / hour',
      example: 'Development broker',
      monthly: '$20',
      note: 'Dev only, no HA',
    },
    {
      name: 'mq.t3.micro active/standby HA',
      unitPrice: '$0.054 / hour',
      example: 'Smallest HA broker',
      monthly: '$40',
      note: 'Light production HA with limited throughput',
    },
    {
      name: 'mq.m5.large single-AZ',
      unitPrice: '$0.288 / hour',
      example: 'Single broker production',
      monthly: '$210',
      note: 'No HA; not recommended for prod',
    },
    {
      name: 'mq.m5.large active/standby HA',
      unitPrice: '$0.576 / hour',
      example: 'Standard production HA',
      monthly: '$420',
      note: 'Two brokers; minimum prod-grade',
      highlight: true,
    },
    {
      name: 'mq.m5.large RabbitMQ cluster',
      unitPrice: '$0.864 / hour',
      example: 'Three-broker cluster',
      monthly: '$630',
      note: 'RabbitMQ only; higher throughput / availability',
    },
    {
      name: 'mq.m5.xlarge active/standby',
      unitPrice: '$1.152 / hour',
      example: 'High-throughput HA broker',
      monthly: '$840',
      note: '2× compute capacity of m5.large',
    },
    {
      name: 'mq.m5.2xlarge active/standby',
      unitPrice: '$2.304 / hour',
      example: 'Largest active/standby HA',
      monthly: '$1,680',
      note: '4× m5.large compute',
    },
    {
      name: 'ActiveMQ storage (EFS)',
      unitPrice: '$0.30 / GB-month',
      example: '200 GB broker storage',
      monthly: '$60',
      note: 'Same rate as EFS Standard',
      highlight: true,
    },
    {
      name: 'RabbitMQ storage (EBS)',
      unitPrice: '$0.10 / GB-month',
      example: '200 GB broker storage',
      monthly: '$20',
      note: '3× cheaper than ActiveMQ storage',
    },
    {
      name: 'Data transfer out (internet)',
      unitPrice: 'Standard EC2 egress',
      example: 'Cross-region or external clients',
      monthly: 'Variable',
      note: 'Use VPC endpoints to keep traffic in-region',
    },
    {
      name: 'Cross-region replication',
      unitPrice: 'Not native; DIY',
      example: 'Custom message-forwarding',
      monthly: 'N/A',
      note: 'MQ has no native multi-region; build your own',
    },
  ]}
  footnote="The HA cost (2 brokers for active/standby) is the minimum operating posture for production. Single-AZ brokers are dev-only."
/>

_If you only audit one dimension first, ask whether the workload **requires JMS/AMQP**. SQS is 80 to 85% cheaper for new designs, as the 100M-message comparison below shows._

## Why a production broker costs $500 to $750 a month

The math:

- mq.m5.large ActiveMQ active/standby HA: $420/month (the smallest broker tier suitable for production HA), or a three-node RabbitMQ cluster at $630/month
- 200 GB ActiveMQ EFS storage: $60/month (or 200 GB RabbitMQ EBS per node across 3 nodes: $60/month)
- Data transfer: $20 to $50/month typical
- CloudWatch monitoring: $10 to $30/month for standard alarms and dashboards

Total: $510 to $560/month for ActiveMQ HA and $720 to $770/month for a RabbitMQ cluster, before any message traffic. For workloads that only need a handful of messages per second, this is dramatically more expensive than the SQS equivalent (which would be measured in dollars per month for the same volume).

<BillSurpriseCallout
  variant="surprise"
  title="MQ broker provisioned and forgotten on a deprecated workload"
  amount="$420+/month indefinitely"
>
  Amazon MQ bills per broker-hour regardless of message traffic. A broker sitting idle after the workload that needed it
  was decommissioned continues to bill at the per-broker-hour rate. Audit active brokers via `aws mq list-brokers`;
  delete brokers whose source applications have been retired.
</BillSurpriseCallout>

## ActiveMQ vs RabbitMQ on MQ

![Architecture diagram of Amazon MQ for ActiveMQ and Amazon MQ for RabbitMQ as alternatives](../../assets/images/blog/amazon-mq-pricing-broker-instance-storage-throughput-engine.webp)

_Figure: the two engines in the article. The rows are alternatives. Both run as Amazon MQ brokers. The broker size and storage stay in the article. [Open the draw.io source](https://www.joinhorizon.co/examples/architecture-blog-2026/amazon-mq-pricing-broker-instance-storage-throughput/engine.drawio)._

Both run on Amazon MQ with the same per-broker-hour pricing. The differences:

<PricingDimensionTable
  title="ActiveMQ vs RabbitMQ on Amazon MQ"
  intro="Same broker pricing; different protocol support, different storage backend, different deployment topologies."
  region="us-east-1"
  dimensions={[
    {
      name: 'Storage backend',
      unitPrice: 'EFS vs EBS',
      example: 'Per-broker storage',
      monthly: 'EFS $0.30 vs EBS $0.10 / GB-month',
      note: 'RabbitMQ storage is 3× cheaper',
    },
    {
      name: 'Protocols supported',
      unitPrice: 'Same broker price',
      example: 'JMS, OpenWire, STOMP, AMQP, MQTT',
      monthly: 'ActiveMQ: 5 protocols',
      note: 'Broadest enterprise compatibility',
    },
    {
      name: 'Protocols supported',
      unitPrice: 'Same broker price',
      example: 'AMQP 0-9-1',
      monthly: 'RabbitMQ: 1 native protocol',
      note: 'Native RabbitMQ client compatibility',
    },
    {
      name: 'HA topology',
      unitPrice: 'Active/standby (2 brokers)',
      example: 'ActiveMQ only',
      monthly: 'Same per-broker price × 2',
      note: 'Failover-based; RabbitMQ uses a single broker or a 3-node cluster instead',
    },
    {
      name: 'Cluster topology',
      unitPrice: '3-broker cluster',
      example: 'RabbitMQ only',
      monthly: '$630/mo (m5.large × 3)',
      note: 'Higher throughput; not available for ActiveMQ',
      highlight: true,
    },
    {
      name: 'Performance',
      unitPrice: 'Same broker price',
      example: 'Throughput per dollar',
      monthly: 'RabbitMQ typically wins on throughput',
      note: 'ActiveMQ wins on protocol compatibility',
    },
  ]}
  footnote="If you don't have an existing JMS dependency, RabbitMQ is usually the right choice on MQ, with cheaper storage and better per-dollar throughput."
/>

## MQ vs SQS vs self-managed RabbitMQ

![Architecture diagram of an application using Amazon MQ and an application using SQS as alternatives](../../assets/images/blog/amazon-mq-pricing-broker-instance-storage-throughput-queue.webp)

_Figure: MQ versus SQS in the article. The rows are alternatives. MQ is a broker you size. SQS is a queue without that broker. A self-managed broker stays in the article. Rates stay in the article. [Open the draw.io source](https://www.joinhorizon.co/examples/architecture-blog-2026/amazon-mq-pricing-broker-instance-storage-throughput/queue.drawio)._

For a workload that needs message queuing, the three managed/quasi-managed options on AWS produce dramatically different bills:

<PricingDimensionTable
  title="Same workload across MQ, SQS, and self-managed RabbitMQ, 100M messages/month"
  intro="Same throughput; different operational model and protocol support."
  region="us-east-1"
  dimensions={[
    {
      name: 'Amazon MQ: RabbitMQ HA',
      unitPrice: 'Broker hours + storage',
      example: 'mq.m5.large 3-node cluster',
      monthly: '~$720/mo',
      note: 'Native AMQP support; HA posture',
    },
    {
      name: 'Amazon MQ: ActiveMQ HA',
      unitPrice: 'Broker hours + EFS',
      example: 'Same broker tier',
      monthly: '~$510/mo',
      note: 'JMS + multi-protocol support',
    },
    {
      name: 'Amazon SQS Standard',
      unitPrice: '$0.40/M requests',
      example: '100M messages = ~200M requests',
      monthly: '~$80/mo',
      note: '84% cheaper than ActiveMQ HA',
      highlight: true,
    },
    {
      name: 'Amazon SQS FIFO',
      unitPrice: '$0.50/M requests',
      example: 'With ordering guarantees',
      monthly: '~$100/mo',
      note: 'Still 80% cheaper than ActiveMQ HA',
    },
    {
      name: 'Self-managed RabbitMQ on EC2',
      unitPrice: 'EC2 + EBS',
      example: '3× t3.large + storage',
      monthly: '~$200/mo + ops',
      note: 'You own broker patching and recovery',
    },
  ]}
  footnote="SQS is dramatically cheaper for the same throughput. MQ's value is exclusively protocol compatibility for applications that cannot move off AMQP/JMS/STOMP."
/>

## When MQ is the right answer

<PricingDecisionCard
  headline="Amazon MQ when AMQP/JMS/STOMP/MQTT/OpenWire compatibility is non-negotiable; SQS for new application development; self-managed RabbitMQ for cost sensitivity with operational capacity."
  useWhen={[
    'Legacy Java enterprise applications using JMS that would require rewrite to migrate to SQS',
    'Integration with vendor systems requiring AMQP (RabbitMQ-compatible) clients',
    'IoT platforms standardized on MQTT with broker requirements',
    'Real-time messaging requiring STOMP, such as financial trading systems, real-time collaboration',
    'Migrations from on-premises ActiveMQ or RabbitMQ where preserving the protocol simplifies the migration',
  ]}
  avoidWhen={[
    'New application development: choose SQS for queues and EventBridge for events',
    'Workloads that can use the AWS SDK, where the MQ premium is wasted',
    'Cost-sensitive workloads with operational capacity to manage their own broker, where self-managed RabbitMQ on EC2 is meaningfully cheaper',
    'Streaming use cases requiring replay or consumer-group semantics, where MSK or Kinesis is the right primitive',
    'Workloads with idle periods: MQ bills per broker-hour regardless of traffic',
  ]}
  footnote="MQ exists for protocol compatibility. If that isn't a hard requirement, the bill is dramatically lower with SQS."
/>

## A 30-day MQ bill cleanup plan

**Week 1: Broker inventory.** List every MQ broker via `aws mq list-brokers`. Identify brokers whose source applications have been retired or deprecated. Delete the unused brokers.

**Week 2: Right-size active brokers.** Review CloudWatch metrics for each broker (CPU utilization, memory, message throughput). Downsize over-provisioned brokers; the broker tier change requires brief downtime but the per-hour cost drops immediately.

**Week 3: Storage audit.** For ActiveMQ brokers, audit EFS storage usage. Implement message-retention policies that delete old messages from queues. For RabbitMQ, audit EBS storage and apply queue TTL policies.

**Week 4: Migration evaluation.** For each remaining MQ workload, evaluate whether the protocol dependency is load-bearing. Document workloads where migration to SQS could happen if the cost savings justify the rewrite.

## More in this series

Part of the **AWS Service Pricing** series (June 2026).

- Previous: [Part 15](https://www.joinhorizon.co/blog/amazon-lightsail-pricing-bundles-vs-ec2-true-total-cost/)
- Next: [Part 17](https://www.joinhorizon.co/blog/amazon-dynamodb-pricing-on-demand-provisioned-gsi-streams/)
- Browse all: [Cost Optimization & FinOps category](https://www.joinhorizon.co/category/cost-optimization-and-finops/)

## What this post doesn't cover

- **Migration from on-premises ActiveMQ / RabbitMQ to Amazon MQ:** operational migration patterns covered in our messaging migration content.
- **MSK (Managed Kafka) pricing in depth:** different primitive (streaming vs messaging); covered in a separate streaming-platform post.
- **Self-managed RabbitMQ HA architecture on EC2:** covered in our messaging architecture content for teams choosing this path.
- **MQ Connector / federation patterns:** covered in messaging-architecture content; usually not bill-relevant.

## If you only do one thing this week

Audit your MQ brokers for active usage. Run `aws mq list-brokers` and for each broker check CloudWatch `SystemActiveConnections` and `MessagesEnqueued` over the last 30 days. Any broker with sustained low or zero traffic is a candidate for deletion or downsizing. Brokers tend to outlive the applications they serve; an audit twice a year catches the orphans before they accumulate.

For the broader messaging-architecture decision (when MQ vs SQS vs Kafka), the [reliable queue systems guide](https://www.joinhorizon.co/blog/reliable-queue-systems-aws-sqs-kafka-redis/) covers the trade-offs and the patterns for migrating between primitives when the workload outgrows the original choice.

## FAQ

### Why is Amazon MQ so much more expensive than SQS?
Different products solving different problems. SQS is a serverless, pay-per-request queue ($0.40 per million requests) with no per-resource hourly cost. Amazon MQ is a managed broker (ActiveMQ or RabbitMQ) that bills per broker instance hour regardless of message traffic. The MQ premium pays for protocol compatibility (AMQP, JMS, STOMP, MQTT, OpenWire) that SQS does not support. If your application speaks JMS (Java enterprise messaging) or AMQP (RabbitMQ-compatible clients) and rewriting to use the SQS SDK is non-trivial, MQ is the right answer. If your application could be rewritten to use SQS, the bill is dramatically lower.

### What is the realistic minimum monthly cost for a production MQ deployment?
Roughly $510 to $770/month for a reasonable HA setup, depending on the engine. The math for ActiveMQ: mq.m5.large active/standby (the smallest production-grade HA configuration) is $0.576/hour or ~$420/month. Add 200 GB EFS storage at $0.30/GB-month ($60/month) and $30 to $80/month for data transfer and monitoring, and you arrive at $510 to $560/month before any actual messaging traffic. RabbitMQ has no active/standby mode: a three-node mq.m5.large cluster is $0.864/hour or ~$630/month, plus 200 GB of EBS per node at $0.10/GB-month ($60/month) and the same transfer and monitoring, for $720 to $770/month. Smaller brokers (mq.t3.micro at $0.027/hour single-AZ, ~$20/month) work for development but lack the HA posture required for production messaging.

### When does the MQ broker actually warrant the cost?
When you have an existing application using AMQP, JMS, STOMP, MQTT, or OpenWire protocols and migrating to SQS/SNS/Kinesis would require non-trivial application rewrite. Common cases: legacy Java enterprise applications using JMS, IoT systems standardized on MQTT, integration platforms using AMQP for vendor compatibility, real-time messaging requiring STOMP. For new application development, choose SQS for queues and EventBridge for events. Both are dramatically cheaper and operationally simpler.

### Should I use ActiveMQ or RabbitMQ on Amazon MQ?
Match to your client protocol. ActiveMQ supports JMS, OpenWire, STOMP, AMQP, MQTT: broad protocol support, classic enterprise Java fit. RabbitMQ on MQ supports AMQP 0-9-1, the canonical RabbitMQ wire protocol and a native fit for applications already speaking AMQP. ActiveMQ on MQ uses EFS for broker storage ($0.30/GB-month), making it more expensive per-GB for high-throughput logging. RabbitMQ on MQ uses EBS ($0.10/GB-month). For cost-sensitive deployments with high message throughput, RabbitMQ on EBS is cheaper for the storage line.

### How does RabbitMQ cluster deployment change the price?
A RabbitMQ cluster on MQ is 3 broker instances. RabbitMQ on MQ has no active/standby mode (that is ActiveMQ), so the alternative is a single broker. The cluster mode provides higher availability and throughput but triples the broker instance cost relative to one broker (and is 1.5× an ActiveMQ active/standby pair): three mq.m5.large brokers run $0.288 × 3 = $0.864/hour or ~$630/month for the brokers alone, plus storage replicated 3× and data transfer between brokers. Cluster mode is operationally more resilient but the cost is meaningful; use only when the throughput or availability requirements actually justify the multi-broker pattern.

### Can I run my own RabbitMQ on EC2 instead?
Yes, and it can be cheaper for cost-sensitive deployments. A self-managed RabbitMQ cluster on EC2 with appropriate sizing typically costs 40 to 60% of the equivalent MQ deployment because you skip the managed-service premium. The trade-off is operational responsibility: you patch RabbitMQ, you handle broker recovery, you size for failure tolerance, you manage backup and snapshots. For teams with strong messaging operations expertise, self-managed RabbitMQ on EC2 is a legitimate choice. For teams that want to focus on application logic and let AWS handle broker management, MQ is correct.

### How does Amazon MSK compare for streaming use cases?
Different primitive entirely. MSK (Managed Kafka) is the right answer for ordered streaming, replay, multi-consumer broadcast patterns, not for traditional message queue semantics. MSK pricing is per-broker-hour similar to MQ but with different broker types (kafka.t3.small starts at ~$0.0456/hour for two-broker minimum). For pure messaging (point-to-point or pub/sub) use SQS/SNS/MQ. For streaming with replay and consumer-group semantics, use MSK or Kinesis. Mixing them on the same workload usually indicates the wrong primitive was chosen somewhere.

---

*Source: https://www.joinhorizon.co/blog/amazon-mq-pricing-broker-instance-storage-throughput/*