---
title: Amazon Aurora Pricing: The I/O-Optimized Crossover and the Serverless v2 ACU Trap
description: Aurora bills instance hours plus storage plus I/O, or storage at a 125% premium with I/O bundled (I/O-Optimized). Serverless v2 at $0.12 per ACU-hour wins on variable workloads, loses on steady traffic above roughly 2 ACU average. Global Database doubles the price per secondary region plus replicated-write fees. Backtrack adds per-change-record cost most teams never factor in.
url: https://www.joinhorizon.co/blog/amazon-aurora-pricing-io-optimized-serverless-v2-global/
datePublished: 2026-06-13T00:00:00.000Z
dateModified: 2026-10-28T00:00:00.000Z
author: kevin-w
category: Cost Optimization & FinOps
tags: amazon-aurora, aurora-pricing, aws-pricing, cost-optimization, finops, database
---

# Amazon Aurora Pricing: The I/O-Optimized Crossover and the Serverless v2 ACU Trap

> Aurora bills instance hours plus storage plus I/O, or storage at a 125% premium with I/O bundled (I/O-Optimized). Serverless v2 at $0.12 per ACU-hour wins on variable workloads, loses on steady traffic above roughly 2 ACU average. Global Database doubles the price per secondary region plus replicated-write fees. Backtrack adds per-change-record cost most teams never factor in.

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';
import PricingCalculatorCta from '~/components/blog/PricingCalculatorCta.astro';

Amazon Aurora is AWS's flagship cloud-native relational database, available in MySQL and PostgreSQL flavors with several deployment shapes (provisioned, Serverless v2, Global Database, Limitless, DSQL). The pricing reflects that breadth: instance hours, two storage models, optional features each with their own line items, and replication multipliers for multi-region. The right shape for a workload depends on traffic pattern, I/O intensity, and consistency requirements. The wrong shape can land the bill 2 to 5 times higher than necessary.

> **Amazon Aurora pricing** covers instance hours, Serverless v2 ACUs, I/O-Optimized storage mode, Global Database replication, and backup storage. In us-east-1, Serverless v2 bills $0.12/ACU-hour (Aurora Standard; $0.16 on I/O-Optimized). Most surprises come from I/O charges on Standard storage for write-heavy workloads and Global Database doubling storage per region.

| Configuration        | Billing unit               | Trap                  |
| -------------------- | -------------------------- | --------------------- |
| Provisioned instance | Per hour                   | Over-provisioned ACUs |
| Serverless v2        | Per ACU-hour               | Min ACU floor         |
| I/O-Optimized        | Higher storage, no per-I/O | Wrong for read-heavy  |
| Global Database      | Per-region storage + IO    | 2+ regions            |

<PricingHeroStats
  stats={[
    { value: '$0.26', label: 'db.r6g.large / hour', note: 'Provisioned baseline; RDS premium' },
    { value: '$0.12', label: 'Serverless v2 / ACU-hour', note: 'Crossover with db.r6g.large at ~2.2 ACU sustained' },
    { value: '125%', label: 'I/O-Optimized storage premium', note: 'In exchange for no per-I/O charge' },
    { value: '2–3×', label: 'Global Database / region', note: 'Each replica region is a full cluster' },
  ]}
  caption="us-east-1 list prices, June 2026. Verify against the AWS Aurora pricing page for your region. Source: [AWS Pricing page](https://aws.amazon.com/rds/aurora/pricing/), us-east-1, retrieved June 2026."
/>
<PricingCalculatorCta blogSlug="amazon-aurora-pricing-io-optimized-serverless-v2-global" />

This post is the bill story. For the broader Aurora-vs-RDS architectural decision, the [Aurora Serverless v2 vs provisioned comparison](https://www.joinhorizon.co/compare/aws-aurora-serverless-vs-aurora-provisioned/) covers the choice within Aurora; the [RDS vs Aurora comparison](https://www.joinhorizon.co/compare/aws-rds-vs-aurora/) covers when Aurora is the right primitive vs standard RDS.

## The Aurora billing dimensions

<PricingDimensionTable
  title="Aurora pricing breakdown, us-east-1, June 2026"
  intro="Instance + storage + I/O is the standard model. Serverless v2 collapses these into per-ACU billing; Global Database compounds per region."
  region="us-east-1"
  dimensions={[
    {
      name: 'db.r6g.large (provisioned)',
      unitPrice: '$0.26 / hour',
      example: '1 instance × 730 hours',
      monthly: '$190',
      note: 'Premium over the standard RDS rate',
      highlight: true,
    },
    {
      name: 'db.r6g.xlarge (provisioned)',
      unitPrice: '$0.52 / hour',
      example: '1 instance × 730 hours',
      monthly: '$380',
      note: 'Doubles per tier',
    },
    {
      name: 'Serverless v2',
      unitPrice: '$0.12 / ACU-hour',
      example: '2 ACU sustained',
      monthly: '$175',
      note: 'Scales by 0.5 ACU increments',
      highlight: true,
    },
    {
      name: 'Standard storage',
      unitPrice: '$0.10 / GB-month + $0.20 / M I/O',
      example: '500 GB + 50M I/O / mo',
      monthly: '$50 + $10 = $60',
      note: 'Cheaper for low-I/O workloads',
    },
    {
      name: 'I/O-Optimized storage',
      unitPrice: '$0.225 / GB-month, no I/O charge',
      example: '500 GB',
      monthly: '$112.50',
      note: 'Break-even at ~25% I/O share of bill',
      highlight: true,
    },
    {
      name: 'Backup storage (above db size)',
      unitPrice: '$0.021 / GB-month',
      example: '500 GB backup beyond db size',
      monthly: '$10.50',
      note: 'Free up to size of source database',
    },
    {
      name: 'Backtrack (Aurora MySQL)',
      unitPrice: '$0.012 / M change-record-hours',
      example: '1M change records stored all month',
      monthly: '$8.76',
      note: 'Billed per change record per hour stored',
    },
    {
      name: 'Aurora Global Database',
      unitPrice: 'Each region: full cluster + $0.20/M replicated writes',
      example: '2-region setup',
      monthly: '2× cluster cost + transfer',
      note: 'Cross-region transfer $0.02/GB',
      highlight: true,
    },
    {
      name: 'Data API',
      unitPrice: 'Free',
      example: 'HTTP query interface',
      monthly: '$0',
      note: 'Useful for Lambda integration',
    },
    {
      name: 'Aurora Limitless (routing + shards)',
      unitPrice: 'ACU-based',
      example: 'Sharded Aurora PostgreSQL',
      monthly: 'Varies with shard count',
      note: 'For workloads beyond single-cluster scale',
    },
  ]}
  footnote="Reserved Instance discounts apply to provisioned Aurora instances (40 to 75% off the on-demand rate depending on term). Serverless v2 has no RI mechanism."
/>

_If you only audit one dimension first, model **I/O-Optimized vs Standard**. Write-heavy OLTP often saves on I/O-Optimized despite higher storage._

## I/O-Optimized vs Standard: the 25% crossover

![Architecture diagram of Aurora Standard and Aurora I/O-Optimized as alternative storage modes](../../assets/images/blog/amazon-aurora-pricing-io-optimized-serverless-v2-global-io.webp)

_Figure: the two storage modes in the article. The rows are alternatives. Standard bills I/O apart from storage. I/O-Optimized folds I/O into the storage rate. The crossover math stays in the article. [Open the draw.io source](https://www.joinhorizon.co/examples/architecture-blog-2026/amazon-aurora-pricing-io-optimized-serverless-v2-global/io.drawio)._

Standard Aurora storage bills $0.10/GB-month plus $0.20 per million I/O operations. I/O-Optimized bills $0.225/GB-month with no per-I/O charge. That is a 125% premium on storage in exchange for unlimited I/O.

The crossover: when I/O costs exceed roughly 25% of your Aurora bill, I/O-Optimized is cheaper.

<PricingDimensionTable
  title="Standard vs I/O-Optimized: 500 GB database, three I/O profiles"
  intro="Same data volume, different I/O rates. The decision is per-cluster, not per-application."
  region="us-east-1"
  dimensions={[
    {
      name: 'Standard, 10M I/O / mo',
      unitPrice: '$50 storage + $2 I/O',
      example: 'Read-mostly low-volume',
      monthly: '$52',
      note: 'Standard wins for low-I/O',
    },
    {
      name: 'I/O-Optimized, same workload',
      unitPrice: '$112.50 flat',
      example: 'Low-I/O workload',
      monthly: '$112.50',
      note: '2× more expensive at low I/O',
      highlight: false,
    },
    {
      name: 'Standard, 500M I/O / mo',
      unitPrice: '$50 storage + $100 I/O',
      example: 'Moderate OLTP',
      monthly: '$150',
      note: 'I/O catching up to storage',
    },
    {
      name: 'I/O-Optimized, same workload',
      unitPrice: '$112.50 flat',
      example: 'Moderate OLTP',
      monthly: '$112.50',
      note: 'I/O-Optimized wins',
      highlight: true,
    },
    {
      name: 'Standard, 2B I/O / mo',
      unitPrice: '$50 storage + $400 I/O',
      example: 'High-throughput OLTP',
      monthly: '$450',
      note: 'I/O dominates',
    },
    {
      name: 'I/O-Optimized, same workload',
      unitPrice: '$112.50 flat',
      example: 'High-throughput OLTP',
      monthly: '$112.50',
      note: '75% cheaper',
      highlight: true,
    },
  ]}
  footnote="The crossover is at roughly 300M I/O / month for a 500 GB database. Beyond that, I/O-Optimized is unconditionally cheaper."
/>

The audit pattern: check CloudWatch `VolumeReadIOPs` and `VolumeWriteIOPs` for your Aurora clusters over the last month, sum to get monthly I/O, multiply by $0.20/M to get the Standard-tier I/O bill, compare against the premium of I/O-Optimized. The decision is per-cluster.

<BillSurpriseCallout
  variant="optimization"
  title="Migrate high-I/O Aurora clusters to I/O-Optimized"
  amount="25 to 75% saving on the storage + I/O line in the scenarios above"
>
  For OLTP workloads with substantial I/O, the I/O-Optimized migration is non-controversial. The cluster operates
  identically and the bill drops. The migration is a one-time storage configuration change (requires brief downtime for the
  storage class swap). For databases approaching the crossover threshold, the change pays for itself in a few months and
  the saving compounds indefinitely.
</BillSurpriseCallout>

## Serverless v2 vs provisioned: the ~2.2-ACU break-even

![Architecture diagram of Aurora Serverless v2 and provisioned Aurora as alternative compute modes](../../assets/images/blog/amazon-aurora-pricing-io-optimized-serverless-v2-global-compute.webp)

_Figure: the two compute shapes in the article. The rows are alternatives. Variable traffic can use Serverless v2. Steady traffic can use a provisioned instance. The break-even stays in the article. Global Database, where each region is a full copy, stays in the article. [Open the draw.io source](https://www.joinhorizon.co/examples/architecture-blog-2026/amazon-aurora-pricing-io-optimized-serverless-v2-global/compute.drawio)._

Serverless v2 bills $0.12 per ACU-hour where 1 ACU represents approximately 2 GB of memory and corresponding CPU/network. The pricing scales linearly: 2 ACU = $0.24/hour, 4 ACU = $0.48/hour, 16 ACU = $1.92/hour.

The break-even with provisioned db.r6g.large at $0.26/hour: roughly 2.2 ACU ($0.26 ÷ $0.12). Above that, Serverless v2 costs more per hour than provisioned for equivalent capacity.

<PricingDimensionTable
  title="Serverless v2 vs provisioned: usage scenarios"
  intro="Serverless v2 wins on variable workloads; provisioned wins on steady traffic above the break-even capacity."
  region="us-east-1"
  dimensions={[
    {
      name: 'Dev / test, scales to 0 nights/weekends',
      unitPrice: 'Serverless v2 avg 0.5 ACU',
      example: '40% of hours active',
      monthly: '~$18',
      note: 'Scaling to zero is the main draw',
      highlight: true,
    },
    {
      name: 'Variable production, avg ~3 ACU, peak 8 ACU',
      unitPrice: 'Serverless v2 avg ~3 ACU',
      example: 'Variable web app load',
      monthly: '~$263',
      note: 'Cheaper than always-on db.r6g.xlarge',
    },
    {
      name: 'Steady production, sustained 4 ACU',
      unitPrice: 'Serverless v2',
      example: '4 ACU × 730h',
      monthly: '$350',
      note: 'Well above the ~2.2 ACU break-even',
    },
    {
      name: 'Same workload on provisioned',
      unitPrice: 'db.r6g.large',
      example: 'Always-on',
      monthly: '$190',
      note: '46% cheaper for steady traffic',
      highlight: true,
    },
    {
      name: 'Steady production, sustained 8 ACU',
      unitPrice: 'Serverless v2',
      example: '8 ACU × 730h',
      monthly: '$700',
      note: 'Significantly more than provisioned',
    },
    {
      name: 'Same workload on provisioned',
      unitPrice: 'db.r6g.xlarge',
      example: 'Always-on',
      monthly: '$380',
      note: '46% cheaper for sustained 8 ACU',
    },
  ]}
  footnote="Scaling to zero on Serverless v2 (supported for dev environments) eliminates the cost when idle, which is the main draw for non-production workloads."
/>

## Global Database: each region is full cost

Aurora Global Database replicates a primary cluster to secondary regions with sub-second replication lag. Each secondary region runs its own Aurora cluster, with full instance cost and full storage cost. The primary also pays for replicated writes ($0.20 per million writes replicated) and the inter-region data transfer ($0.02/GB).

A 2-region Global Database with db.r6g.xlarge instances effectively doubles the database tier cost, from $380/month to $760+/month for the instances alone. A 3-region setup roughly triples it.

The right use cases:

- **Active-active multi-region writes**: applications where users in different regions write locally and replicate globally. (For pure active-active write workloads, evaluate Aurora DSQL, which is the newer primitive.)
- **Sub-second cross-region read locality**: serving users in multiple regions with local-latency reads.
- **Low-RPO disaster recovery**: cross-region failover with under-1-minute RPO.

The wrong use case: standard DR with relaxed RPO. A single-region cluster with cross-region automated snapshots achieves multi-hour RPO at dramatically lower cost.

## Backtrack: the quiet per-change-record line

Aurora Backtrack (MySQL only) lets you rewind the cluster to a point within the configured retention window (up to 72 hours) without restoring from a backup. The cost: $0.012 per million change records per hour stored.

For low-write databases, this is essentially free. For high-write OLTP databases generating hundreds of millions of change records per day, the line item becomes material. A database with 500M change records/day at 72-hour retention keeps about 1.5B records stored, which bills ~$18/hour, about $430/day or ~$13,000/month for Backtrack alone. Cutting retention to 24 hours cuts that by two thirds.

The mitigations:

- **Match retention to operational need.** 24-hour retention covers "rewind that bad deploy from this morning"; 72-hour retention is rarely operationally useful.
- **Evaluate vs PITR.** Point-in-Time Recovery from automated backups is free but slower (full restore from snapshot + log replay). For low-frequency rewind use cases, PITR may suffice.

## When to use each Aurora shape

<PricingDecisionCard
  headline="Provisioned for steady production; Serverless v2 for variable / dev; Global Database for multi-region requirements; Limitless for beyond-single-cluster scale."
  useWhen={[
    'Provisioned Aurora: steady production traffic above ~2.2 ACU average; predictable load',
    'Provisioned + Reserved Instances: predictable production for 1+ year of usage, with a substantial discount',
    'Serverless v2: variable production traffic with high peak-to-average ratio; dev/test with scale-to-zero',
    'I/O-Optimized storage: workloads with sustained I/O above ~25% of the bill',
    'Global Database: multi-region active-active writes, sub-second cross-region read locality, low-RPO DR',
    'Aurora Limitless: workloads that exceed single-cluster scale and need automatic sharding',
    'Aurora DSQL: serverless distributed SQL with multi-region active-active for greenfield workloads',
  ]}
  avoidWhen={[
    'Serverless v2 for steady high-utilization workloads: provisioned is cheaper',
    'Standard storage on high-I/O workloads: I/O-Optimized saves money',
    'Global Database for pure read replication: DAX, app-side cache, or read replica is cheaper',
    'Backtrack on high-write databases without retention discipline: silent line item',
    'Aurora when standard RDS would suffice: Aurora carries a ~20% instance premium',
  ]}
  footnote="Aurora is rarely the wrong primitive at the architecture level. The bill problems come from storage class selection, deployment shape, and multi-region overcommit."
/>

## A 30-day Aurora bill cleanup plan

**Week 1: I/O-Optimized evaluation.** For each Aurora cluster, calculate the actual I/O volume (CloudWatch `VolumeReadIOPs` + `VolumeWriteIOPs` × 30 days). Compare the Standard vs I/O-Optimized cost. Migrate clusters where I/O-Optimized saves money.

**Week 2: Serverless v2 fit audit.** Identify clusters on Serverless v2 with sustained ACU consumption above the break-even. Migrate to provisioned. Identify clusters on provisioned with low average utilization and evaluate migration to Serverless v2.

**Week 3: Global Database scope.** Review Global Database setups against actual cross-region usage. Where the secondary region is purely DR with relaxed RPO, evaluate replacement with cross-region snapshots.

**Week 4: Backtrack and dev-environment scale-to-zero.** Audit Backtrack retention on high-write databases. Configure scale-to-zero on Serverless v2 dev environments to eliminate idle-time cost.

## More in this series

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

- Previous: [Part 17](https://www.joinhorizon.co/blog/amazon-dynamodb-pricing-on-demand-provisioned-gsi-streams/)
- Next: [Part 19](https://www.joinhorizon.co/blog/amazon-eks-pricing-control-plane-addons-auto-mode/)
- Browse all: [Cost Optimization & FinOps category](https://www.joinhorizon.co/category/cost-optimization-and-finops/)

## What this post doesn't cover

- **Aurora DSQL** pricing in depth: newer serverless distributed SQL primitive with its own pricing model; covered in our database modernization content.
- **Aurora performance tuning:** relevant to bill (reducing I/O reduces Standard tier cost) but covered in our database operations content.
- **Migration from RDS to Aurora:** operational migration patterns covered in database migration content.
- **Aurora compatibility-mode specifics** (MySQL vs PostgreSQL feature differences affecting cost): covered separately.

## If you only do one thing this week

Calculate I/O volume for your largest Aurora cluster and decide whether I/O-Optimized would be cheaper. Run a CloudWatch query: sum `VolumeReadIOPs` + `VolumeWriteIOPs` over 30 days, multiply by $0.20/M. If the result exceeds 25% of your current Aurora bill for that cluster, migrate to I/O-Optimized. The migration is a one-time storage configuration change; the bill drops on day one and the saving compounds indefinitely.

For the broader RDS-vs-Aurora architectural decision, the [RDS vs Aurora comparison](https://www.joinhorizon.co/compare/aws-rds-vs-aurora/) covers when Aurora's premium is worth it.

## FAQ

### When does I/O-Optimized Aurora pay off vs Standard?
The crossover is when I/O costs exceed roughly 25% of your Aurora bill. Standard at $0.10/GB-month storage plus $0.20 per million I/O operations is cheaper for low-I/O workloads. I/O-Optimized at $0.225/GB-month storage with no per-I/O charge is cheaper once I/O becomes a substantial line item. For OLTP workloads with heavy read/write patterns (typical SaaS application databases), I/O-Optimized usually wins. For low-volume databases, Standard remains cheaper. Run the calculation against actual VolumeBytesUsed and VolumeReadIOPs / VolumeWriteIOPs CloudWatch metrics before committing.

### When does Aurora Serverless v2 beat provisioned?
Serverless v2 at $0.12 per ACU-hour wins on variable workloads where average utilization is well below peak. The break-even with a provisioned db.r6g.large ($0.26/hour, 16 GiB, about 8 ACU of memory) is about 2.2 ACU of average usage; below that, Serverless v2 is cheaper. Above it, provisioned db.r6g.large is cheaper because the ACU rate compounds linearly while provisioned bills the same hourly rate regardless of utilization. The right pattern: Serverless v2 for dev/test, intermittent workloads, and applications with high peak-to-average ratios; provisioned for steady production above db.r6g.large equivalent capacity.

### How much does Aurora Global Database actually cost?
Each Global Database region runs its own Aurora cluster with full instance and storage costs. A primary region with one db.r6g.xlarge replica region adds roughly the full instance cost ($420/month per db.r6g.xlarge) plus the replica storage cost plus $0.20 per million replicated writes plus inter-region data transfer. A 2-region Global Database approximately doubles the database tier cost; a 3-region setup roughly triples it. Use Global Database when you need cross-region read locality (sub-second secondary reads) or active-active writes (Aurora DSQL is the newer primitive for active-active). For pure DR with relaxed RPO, a single-region cluster with cross-region snapshots is dramatically cheaper.

### What is the cost of enabling Backtrack on Aurora MySQL?
Backtrack bills $0.012 per million change records stored per hour, with a retention window of up to 72 hours configurable per cluster. The actual bill depends on the database's write rate. A high-write OLTP database can generate hundreds of millions of change records per day, translating to a real monthly line item. Backtrack is useful for 'rewind the database 5 minutes to before that bad deploy' scenarios, but it is not free. For low-write-rate databases, Backtrack is essentially free; for high-write databases, evaluate whether traditional point-in-time recovery (free, but slower restore) would meet the operational need.

### Is Aurora Serverless v2 with min ACU 0 actually serverless?
Aurora Serverless v2 supports auto-pause to zero ACUs with the introduction of "scaling to zero" capability, which is useful for dev / test environments that should not bill when idle. The trade-off: scaling from zero to actively serving a request introduces cold-start latency (seconds to tens of seconds depending on configuration). For production workloads, configure a minimum ACU greater than zero (typically 0.5 or 1) to keep the cluster warm. For dev environments, min ACU 0 is the right setting and can dramatically reduce non-production database spend.

### How do Aurora Reserved Instances compare to standard RDS RIs?
Aurora Reserved Instances follow the same model as standard RDS RIs: 1-year or 3-year terms with All-Upfront, Partial-Upfront, or No-Upfront payment options. The discount range is similar (40 to 60% for 1-year, 60 to 75% for 3-year). Aurora RIs cover the instance cost only, not storage or I/O. For predictable production Aurora workloads, RIs deliver substantial savings; for variable workloads, on-demand or Serverless v2 is more flexible. Note that Aurora RIs are not interchangeable with standard RDS RIs and cannot be applied across the line.

### What is Aurora Limitless and how does it price differently?
Aurora Limitless is the horizontally sharded Aurora variant, with automatic sharding for PostgreSQL workloads beyond what a single Aurora cluster can handle. Pricing is based on routing layer + shard groups + standard Aurora storage. The routing layer bills similar to Aurora Serverless v2 ACUs; shard groups bill per provisioned ACU-equivalent capacity. Limitless is the right primitive for workloads that have outgrown vertical Aurora scaling and need automatic sharding without application-level partition management. The total cost is typically higher than a single Aurora cluster but covers workloads beyond what a single cluster can serve.

---

*Source: https://www.joinhorizon.co/blog/amazon-aurora-pricing-io-optimized-serverless-v2-global/*