Amazon RDS Free Tier in 2026: Limits for New and Old Accounts, the $200 Credits, and Why You Are Being Charged (MySQL 8.0 Extended Support Is the Big One)

The Amazon RDS free tier depends on when you opened your AWS account. Accounts created on or after July 15, 2025 get up to $200 in AWS credits and a Free plan for up to 6 months, which covers RDS on db.t3.micro and db.t4g.micro instances running MySQL, PostgreSQL, MariaDB or SQL Server Express, and also Aurora PostgreSQL Serverless up to 4 ACUs and 1 GiB of storage. Older accounts keep the legacy 12-month free tier: 750 hours a month of a Single-AZ micro instance, 20 GB of storage and 20 GB of backup storage. Either way, a "free" database can still charge you, and in late 2026 the biggest surprise is not storage or Multi-AZ. It is RDS Extended Support: MySQL 8.0 left standard support on July 31, 2026, and since August 1 every MySQL 8.0 database that was not upgraded is billed $0.10 per vCPU per hour, about $146 a month for a two-vCPU micro instance whose own hourly price is about $11.68 a month. To check yours, look for ExtendedSupport lines under Relational Database Service in your bill; to stop the charge, upgrade to MySQL 8.4 or PostgreSQL 14 or later.

Jake opened his AWS account in 2025, before the July change, and Ethan set up a small MySQL database for the shop's loyalty-points app on the free tier. It cost nothing for a year, as promised. Then the October bill arrived with a line nobody recognized, ExtendedSupport:Yr1-Yr2:MySQL8.0, and a total bigger than the shop's phone bill. "It's the same tiny database," Jake said. "What changed?" Nothing had changed. That was the problem.

This guide explains what the RDS free tier covers under both the new credit model and the legacy 12-month model, every way a "free" RDS database starts charging, how to read those charges on your bill, and how to create a database that stays inside the limits. If RDS itself is new to you, what Amazon RDS is covers instances, engines and storage first.

RDS free tier for new accounts (since July 15, 2025)

On July 15, 2025, AWS replaced the old "12 months of service-specific allowances" with a credit model for new customers. For RDS, that means:

• Credits: up to $100 at sign-up, plus up to $100 more for completing onboarding activities, $200 in total, usable across eligible services, including RDS and Aurora.
• Free plan: you are enrolled automatically. It lasts until the earlier of 6 months after you opened the account or the moment your credits run out. It cannot be extended.
• Eligible RDS instances on the Free plan: db.t3.micro and db.t4g.micro, with MySQL, PostgreSQL, MariaDB, or Microsoft SQL Server Express Edition.
• Aurora: Aurora PostgreSQL Serverless on the Free plan up to 4 Aurora Capacity Units (ACUs) and 1 GiB of storage per cluster; Aurora DSQL is "always free" up to 100,000 Distributed Processing Units and 1 GiB of storage a month.
• Paid plan: you can switch at any time. Credits keep applying, and charges start once they are used up.

The important difference from the old model: on the Free plan, usage is paid out of your credits. A database that runs up charges does not send you a bill at first, but it eats the $200, and when the credits or the 6 months run out, the Free plan ends and the account must move to a Paid plan to keep running. The AWS Free Tier credits model explains both clocks in detail, and the Cost and Usage widget on the console home page shows your credit balance and plan end date.

RDS free tier limits for older accounts (legacy 12-month tier)

If you opened your account before July 15, 2025, you keep the legacy free tier until 12 months after your sign-up date. For RDS it includes, each month:

• 750 instance hours of an eligible Single-AZ micro instance (such as db.t3.micro or db.t4g.micro) running MySQL, MariaDB, PostgreSQL, or SQL Server Express;
• 20 GB of General Purpose (SSD) storage;
• 20 GB of backup storage for automated backups and user-initiated snapshots.

750 hours is one instance running all month (a month has at most 744 hours). It is a pool, not a per-instance allowance: two micro instances running all month use about 1,460 hours, and the second half is billed. When the 12 months end, or as soon as you use something outside these limits, you pay the normal on-demand rates. All accounts, new and old, pay the standard rates for anything the free tier does not name. AWS Free Tier types compares 12-month, always-free and trial offers.

The biggest 2026 surprise: RDS Extended Support

RDS supports each major engine version for a set period. When a version reaches its end of standard support date, RDS does not stop your database and does not upgrade it. It enrolls it in RDS Extended Support automatically and, from the next day, adds an hourly charge per vCPU. The free tier never covered this charge: it pays for instance hours, storage and backups, not for running a version past its support date. The dates that matter for small databases in late 2026:

Both micro classes have 2 vCPUs. So a db.t4g.micro on MySQL 8.0 that has run all month since August costs, per month:

Extended Support:  $0.10 x 2 vCPU x 730 hours = $146.00
Instance hours:    $0.016 x 730 hours         =  $11.68   (covered by the free tier, if you still have it)
Multi-AZ standby:  Extended Support applies to the standby too, so double the first line

That is the line Jake found: twelve times the price of the database itself, for a database that never changed. Ethan upgraded it to MySQL 8.4 the same afternoon. How to check and stop it:

# which engine versions and lifecycle settings do my databases have?
aws rds describe-db-instances \
  --query 'DBInstances[].{db:DBInstanceIdentifier,engine:Engine,version:EngineVersion,class:DBInstanceClass,lifecycle:EngineLifecycleSupport}' \
  --output table

# upgrade to a supported major version (test first: major upgrades can break apps)
aws rds modify-db-instance --db-instance-identifier shop-db \
  --engine-version 8.4.11 --allow-major-version-upgrade --apply-immediately

The charge stops when you upgrade to a version under standard support or delete the database. For new databases, you can refuse Extended Support up front with --engine-lifecycle-support open-source-rds-extended-support-disabled: creating a database on a version past its end date then fails instead of silently costing money, and a database with that setting is upgraded to the next supported major version instead of being enrolled when its version reaches end of standard support. The upgrade path is MySQL 8.0 to 8.4 and PostgreSQL 13 to 14 or later; back up first and test on a snapshot restore if the app matters.

Every way a free RDS database starts charging

Extended Support is the newest leak, not the only one. In the order they most often appear on a free-tier bill:

Two of these deserve a sentence more. Stopping is not pausing the bill. While a database is stopped, you are not charged for instance hours, but you are still charged for its storage, its backups and snapshots, and its public IPv4 address if it has one. And RDS starts a database that has been stopped for seven consecutive days automatically, so "I stopped it in March" usually means "it has been running since the second week of March".

Storage only grows. You can raise allocated storage but not lower it. A database created with 100 GB "to be safe" bills 80 GB beyond the free 20 GB every month until you migrate to a new, smaller instance. The console's Production template also defaults to Multi-AZ, which is why the Free tier template matters. Charged on the AWS Free Tier? covers the leaks outside RDS, from EBS volumes to NAT gateways.

How to create an RDS database that stays inside the free tier

1. In the RDS console, choose Create database, then Standard create.
2. Pick MySQL or PostgreSQL (or MariaDB), and a version under standard support: MySQL 8.4 or PostgreSQL 17, not 8.0 or 13.
3. Under Templates, choose Free tier. It selects a micro class and Single-AZ and hides the options that cost money.
4. Check the instance class: db.t4g.micro or db.t3.micro.
5. Storage: 20 GB General Purpose SSD, and turn off storage autoscaling.
6. Connectivity: Public access: No. Connect from an EC2 instance or through Session Manager port forwarding instead.
7. Backups: keep automated backups (1 to 7 days is plenty) and avoid manual snapshots you will forget.
8. Create, then set an AWS Budget alert at a few dollars so any leak emails you within a day. AWS billing and budgets shows how.

The same database from the AWS CLI, with Extended Support refused up front and the password kept in Secrets Manager. The request shape was checked against the current SDK model (botocore 1.43.118):

aws rds create-db-instance \
  --db-instance-identifier shop-db \
  --engine mysql --engine-version 8.4.11 \
  --db-instance-class db.t4g.micro \
  --allocated-storage 20 --storage-type gp3 \
  --no-multi-az --no-publicly-accessible \
  --backup-retention-period 1 \
  --master-username admin --manage-master-user-password \
  --engine-lifecycle-support open-source-rds-extended-support-disabled

Leaving out --max-allocated-storage keeps storage autoscaling off when you create from the CLI. For an existing database, the fixes are one modify-db-instance call each: --no-multi-az, --no-publicly-accessible, and --max-allocated-storage set equal to the allocated size to stop further growth.

A free-tier leak audit for all your RDS databases

This read-only script lists every RDS instance in a Region and flags each setting from the table above. It only calls DescribeDBInstances, so it is safe to run with read-only credentials:

import re, sys, boto3, datetime

END_OF_STANDARD = {  # RDS end of standard support (release calendars, October 2026)
    ("mysql", "5.7"): "2024-02-29", ("mysql", "8.0"): "2026-07-31", ("mysql", "8.4"): "2029-07-31",
    ("postgres", "11"): "2024-02-29", ("postgres", "12"): "2025-02-28", ("postgres", "13"): "2026-02-28",
    ("postgres", "14"): "2027-02-28", ("postgres", "15"): "2028-02-29", ("postgres", "16"): "2029-02-28",
    ("postgres", "17"): "2030-02-28",
}
FREE_CLASSES = {"db.t3.micro", "db.t4g.micro"}

def major(engine, version):  # "8.0.43" -> "8.0" for MySQL, "13.20" -> "13" for PostgreSQL
    return re.match(r"\d+\.\d+" if engine == "mysql" else r"\d+", version).group()

def audit(rds, today=None):
    today = today or datetime.date.today().isoformat()
    for page in rds.get_paginator("describe_db_instances").paginate():
        for db in page["DBInstances"]:
            e, v, flags = db["Engine"], db["EngineVersion"], []
            if db["DBInstanceClass"] not in FREE_CLASSES:
                flags.append(f"class {db['DBInstanceClass']} is not free-tier eligible")
            if db.get("MultiAZ"):
                flags.append("Multi-AZ: the standby is billed")
            if db.get("AllocatedStorage", 0) > 20:
                flags.append(f"{db['AllocatedStorage']} GB storage: over 20 GB is billed")
            if db.get("MaxAllocatedStorage", 0) > 20:
                flags.append(f"storage autoscaling up to {db['MaxAllocatedStorage']} GB")
            if db.get("PubliclyAccessible"):
                flags.append("publicly accessible: public IPv4 address charge")
            end = END_OF_STANDARD.get((e, major(e, v)))
            if end and end < today:
                flags.append(f"{e} {major(e, v)} past standard support ({end}): Extended Support charges per vCPU-hour")
            print(f"{db['DBInstanceIdentifier']:<14} {e} {v:<7} {db['DBInstanceClass']:<13} {db['DBInstanceStatus']}")
            for f in flags or ["no free-tier leaks found in these settings"]:
                print("   -", f)

audit(boto3.client("rds", region_name=sys.argv[1] if len(sys.argv) > 1 else None))

Run against three test databases built to show each problem (an RDS-compatible mock endpoint, with the date set to October 23, 2026):

shop-db        mysql 8.0.43  db.t4g.micro  available
   - mysql 8.0 past standard support (2026-07-31): Extended Support charges per vCPU-hour
test-db        mysql 8.4.6   db.t4g.micro  available
   - storage autoscaling up to 1000 GB
   - publicly accessible: public IPv4 address charge
reports-db     postgres 13.20   db.t3.small   available
   - class db.t3.small is not free-tier eligible
   - Multi-AZ: the standby is billed
   - 50 GB storage: over 20 GB is billed
   - postgres 13 past standard support (2026-02-28): Extended Support charges per vCPU-hour

Run it once per Region you have used; databases in a forgotten Region are a classic source of "I deleted everything" bills. It does not look at manual snapshots, so check those separately with aws rds describe-db-snapshots --snapshot-type manual.

How to see what RDS is charging you for

In the console: Billing and Cost Management, Bills, expand Relational Database Service, then your Region. Each line is a usage type, and the names tell you the leak:

• ExtendedSupport:Yr1-Yr2:MySQL8.0 (or PostgreSQL13): Extended Support.
• RDS:ChargedBackupUsage: backup and snapshot storage beyond the free amount.
• RDS:GP2-Storage or RDS:GP3-Storage: allocated storage.
• Instance-hour lines naming Multi-AZ, or a class other than micro.
• Public IPv4 address hours appear under the VPC public IPv4 line, not under RDS.

The same breakdown from the CLI with Cost Explorer (which costs $0.01 per request):

aws ce get-cost-and-usage \
  --time-period Start=2026-10-01,End=2026-10-23 \
  --granularity MONTHLY --metrics UnblendedCost \
  --filter '{"Dimensions":{"Key":"SERVICE","Values":["Amazon Relational Database Service"]}}' \
  --group-by Type=DIMENSION,Key=USAGE_TYPE

On the new Free plan, these lines may show charges while your out-of-pocket total stays $0, because credits absorb them. That is not a sign the database is free; it is a sign the credits are going down. The 10 most common AWS surprise charges covers the rest of the bill.

What a small RDS database costs after the free tier

When the free period ends, or for anything outside it, RDS bills by the hour for the instance plus by the GB-month for storage and backups. On-demand prices for small Single-AZ MySQL and PostgreSQL instances in US East (N. Virginia), October 2026, with 730 hours as a month:

Add $0.115 per GB-month for gp2 or gp3 storage (20 GB is $2.30), $0.095 per GB-month for backup storage beyond the free amount (RDS includes backup storage up to 100 percent of your total database storage in the Region, so most small databases never pay it), $0.005 per hour for a public IPv4 address, and double the instance price for Multi-AZ. So a typical small MySQL database after the free tier (db.t4g.micro, 20 GB, private, Single-AZ, a short backup retention) costs about $14 a month. The same database on MySQL 8.0 costs about $160. Graviton (t4g) is the cheaper choice at every size; t3 exists for workloads that need x86.

Reserved instances and Database Savings Plans (one-year commitments) cut these prices for databases you will keep running. RDS vs Aurora pricing compares small RDS with Aurora Serverless at these sizes.

Is Aurora on the free tier?

Under the legacy free tier, no: Aurora was never part of the 12-month allowances. Under the new model, yes, in a limited form: on the Free plan, Aurora PostgreSQL Serverless runs up to 4 ACUs with 1 GiB of storage per cluster, paid from your credits, and Aurora DSQL is always free up to 100,000 DPUs and 1 GiB of storage a month. Larger Aurora workloads need the Paid plan. For a tiny app, a micro RDS instance and Aurora Serverless cost about the same; RDS vs Aurora pricing compares them for small databases.

Free-tier RDS best practices

1. Start on a supported version (MySQL 8.4, PostgreSQL 16 or 17) so the next end-of-support date is years away.
2. Add the engine version to your calendar: Extended Support starts the day after end of standard support, without an email that says "this will cost $146 a month".
3. Use the Free tier template and keep Single-AZ, 20 GB, no autoscaling, no public access.
4. Delete, do not stop, a database you will not use for more than a week; keep a final snapshot if you need the data, and delete that when you are done.
5. Set a budget alert at a few dollars on day one.
6. Run the audit script in every Region you have touched, once a month.

Troubleshooting by symptom

My free-tier RDS bill suddenly jumped in August 2026

Look for ExtendedSupport lines. MySQL 8.0 left standard support on July 31, 2026; upgrade to 8.4.

I am charged for RDS but my instance is micro

Check Multi-AZ, storage over 20 GB, backup storage, a second instance, and Extended Support on old versions.

I stopped my database but it is running again

RDS restarts a database stopped for seven consecutive days. Delete it, with a final snapshot, if you do not need it.

I deleted the database but RDS charges continue

Manual snapshots survive the database. List them with describe-db-snapshots and delete the ones you do not need.

I cannot reduce my storage to 20 GB

RDS storage cannot shrink. Create a new 20 GB instance and move the data with a dump and restore.

My Free plan ended and the database stopped working

The Free plan ends after 6 months or when credits run out. Upgrade to a Paid plan to keep resources running.

Frequently asked questions

Jake's loyalty-points database now runs MySQL 8.4 on the same micro instance, and its line on the bill is back to almost nothing. Ethan put two dates in the shop calendar: the end of the free tier, and July 31, 2029. "What happens in 2029?" Jake asked. "The same thing as this year," Ethan said, "unless we upgrade first."

Revision note. Written October 23, 2026, twelve weeks after MySQL 8.0 left RDS standard support. "There is no such thing as a free lunch," the proverb says; with RDS, the lunch is free, but the old recipe is not.