---
title: Amazon MQ Pricing: $700/Month Before Your First Message
description: Amazon MQ bills per broker instance hour — an mq.m5.large active/standby HA pair is ~$440/month before storage. Add EFS or EBS for the broker, and a typical production HA deployment lands at $700+/month with zero messages flowing. Use MQ only when AMQP, JMS, STOMP, MQTT, or OpenWire protocol compatibility is non-negotiable.
url: https://www.factualminds.com/blog/amazon-mq-pricing-broker-instance-storage-throughput/
datePublished: 2026-06-13T00:00:00.000Z
dateModified: 2026-06-13T00:00:00.000Z
author: palaniappan-p
category: Cost Optimization & FinOps
tags: amazon-mq, mq-pricing, aws-pricing, cost-optimization, finops, messaging
---

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

> Amazon MQ bills per broker instance hour — an mq.m5.large active/standby HA pair is ~$440/month before storage. Add EFS or EBS for the broker, and a typical production HA deployment lands at $700+/month 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 $700/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.

<PricingHeroStats
  stats={[
    { value: '$700+', label: 'Min production / month', note: 'HA broker + storage; zero messages' },
    { value: '$0.30/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×', label: 'Cluster vs active/standby', note: 'RabbitMQ cluster mode broker count' },
  ]}
  caption="us-east-1 list prices, June 2026. Verify against the AWS MQ pricing page for your region."
/>

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](/blog/reliable-queue-systems-aws-sqs-kafka-redis/) covers the trade-offs.

## The Five 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.04 / hour',
      example: 'Development broker',
      monthly: '$29',
      note: 'Dev only — no HA',
    },
    {
      name: 'mq.t3.micro active/standby HA',
      unitPrice: '$0.08 / hour',
      example: 'Smallest HA broker',
      monthly: '$58',
      note: 'Light production HA — limited throughput',
    },
    {
      name: 'mq.m5.large single-AZ',
      unitPrice: '$0.30 / hour',
      example: 'Single broker production',
      monthly: '$220',
      note: 'No HA; not recommended for prod',
    },
    {
      name: 'mq.m5.large active/standby HA',
      unitPrice: '$0.60 / hour',
      example: 'Standard production HA',
      monthly: '$440',
      note: 'Two brokers; minimum prod-grade',
      highlight: true,
    },
    {
      name: 'mq.m5.large RabbitMQ cluster',
      unitPrice: '$0.90 / hour',
      example: 'Three-broker cluster',
      monthly: '$660',
      note: 'RabbitMQ only; higher throughput / availability',
    },
    {
      name: 'mq.m5.xlarge active/standby',
      unitPrice: '$1.20 / hour',
      example: 'High-throughput HA broker',
      monthly: '$880',
      note: '2× compute capacity of m5.large',
    },
    {
      name: 'mq.m5.2xlarge active/standby',
      unitPrice: '$2.40 / hour',
      example: 'Largest active/standby HA',
      monthly: '$1,750',
      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."
/>

## Why $700/Month Is the Realistic Production Entry Point

The math:

- mq.m5.large active/standby HA: $440/month (the smallest broker tier suitable for production HA)
- 200 GB ActiveMQ EFS storage: $60/month (or 200 GB RabbitMQ EBS: $20/month)
- Data transfer: $20–$50/month typical
- CloudWatch monitoring: $10–$30/month for standard alarms and dashboards

Total: ~$700/month for ActiveMQ HA, ~$520/month for RabbitMQ HA, 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="$440+/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

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: 'Both options support',
      monthly: 'Same per-broker price × 2',
      note: 'Failover-based; standby waits to take over',
    },
    {
      name: 'Cluster topology',
      unitPrice: '3-broker cluster',
      example: 'RabbitMQ only',
      monthly: '$660/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 — cheaper storage and better per-dollar throughput."
/>

## The Real Comparison: MQ vs SQS vs Self-Managed RabbitMQ

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 active/standby',
      monthly: '~$480/mo',
      note: 'Native AMQP support; HA posture',
    },
    {
      name: 'Amazon MQ — ActiveMQ HA',
      unitPrice: 'Broker hours + EFS',
      example: 'Same broker tier',
      monthly: '~$520/mo',
      note: 'JMS + multi-protocol support',
    },
    {
      name: 'Amazon SQS Standard',
      unitPrice: '$0.40/M requests',
      example: '100M messages = ~200M requests',
      monthly: '~$80/mo',
      note: '85% cheaper than MQ',
      highlight: true,
    },
    {
      name: 'Amazon SQS FIFO',
      unitPrice: '$0.50/M requests',
      example: 'With ordering guarantees',
      monthly: '~$100/mo',
      note: 'Still 80% cheaper than MQ 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 — 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 — the MQ premium is wasted',
    'Cost-sensitive workloads with operational capacity to manage their own broker — self-managed RabbitMQ on EC2 is meaningfully cheaper',
    'Streaming use cases requiring replay or consumer-group semantics — MSK or Kinesis is the right primitive',
    'Workloads with idle periods — MQ bills per broker-hour regardless of traffic',
  ]}
  footnote="MQ exists for one reason: protocol compatibility. If protocol compatibility isn't load-bearing, 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 genuinely load-bearing. Document workloads where migration to SQS could happen if the cost savings justify the rewrite.

## 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](/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?
Around $700/month for a reasonable HA setup. The math: mq.m5.large active/standby (the smallest production-grade HA configuration) is $0.60/hour or ~$440/month. Add typical broker storage — 200 GB EFS for ActiveMQ at $0.30/GB-month is $60/month, or 200 GB EBS for RabbitMQ at $0.10/GB-month is $20/month. Add data transfer, monitoring overhead, and you arrive at roughly $700/month before any actual messaging traffic. Smaller brokers (mq.t3.micro at $0.04/hour single-AZ) 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, 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 rather than the 2 in active/standby. The cluster mode provides higher availability and throughput but triples the broker instance cost — three mq.m5.large brokers run $0.30 × 3 = $0.90/hour or ~$660/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–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.factualminds.com/blog/amazon-mq-pricing-broker-instance-storage-throughput/*