AWS Builder Center
 AWS service end-of-support dates: open dataset

AWS service end-of-support dates: open dataset

Open JSON dataset of AWS service lifecycle dates for nine services: end-of-support and Extended Support timelines, post-deprecation behavior, sources.

AWS service end-of-support dates: open dataset

Updated 2026-10-21 - fully revised for v2.0. AWS has since made the AWS Health Version Catalog API ( DescribeServiceLifecycle ) generally available, a first-party source for service version lifecycle dates. We rebuilt this dataset on that API so the dates are now first-party and authoritative, and enriched it with a normalized  serviceCode , a parsed  engine  /  versionNumber , a computed  status , and a per-event  behavior  block for what actually happens when support ends. This is a breaking change (the data is now a flat  entries[]  array). If you pinned to a v1.x release tag you are unaffected; v2 is the recommended path. See the  CHANGELOG  and the  migration guide . Coming next: operational and security metadata, a release change log, and monthly update automation, see the  roadmap .
Today we are releasing a major update to  aws-service-eol-data , a machine-readable JSON dataset that consolidates AWS service version lifecycle dates into a single file. Version 2.0 is rebuilt on the structure of the GA AWS Health Version Catalog API ( DescribeServiceLifecycle ) and enriches it with a normalized  serviceCode , a parsed  engine  and  versionNumber , a computed  status , and per-event  behavior , so you can integrate lifecycle intelligence programmatically into your FinOps platforms, ITSM systems, compliance dashboards, CI/CD pipelines, and upgrade-planning workflows.

What's in the dataset

 data/eol.json  contains a flat array of per-version  entries , 313 versions across 11 AWS services. 289 come straight from the API; 24 versions the API does not return yet (13 deprecated Lambda runtimes, Aurora PostgreSQL 18, Aurora MySQL 8.4, and 9 Amazon MQ versions) come from AWS documentation and are marked  DOCS_CRAWLED  with the page they came from:
  • Amazon EKS (Kubernetes versions)
  • Amazon RDS (MySQL, PostgreSQL, MariaDB)
  • Amazon Aurora (MySQL, PostgreSQL)
  • AWS Lambda (Python, Node.js, Java, .NET, Ruby, Go, and OS-only runtimes)
  • Amazon ElastiCache (Redis OSS, Valkey)
  • Amazon OpenSearch Service (OpenSearch and Elasticsearch legacy)
  • Amazon MSK (Apache Kafka)
  • Amazon DocumentDB
  • Amazon EMR (release series)
  • Amazon MQ (ActiveMQ, RabbitMQ)
  • Amazon Bedrock (foundation models)
For each version you get:
  •  service ,  serviceCode  (normalized, e.g.  rds  vs  rds-aurora ),  engine ,  version  (the raw API id), and  versionNumber  (the parsed bare version)
  • a computed  status  ( STANDARD_SUPPORT ,  EXTENDED_SUPPORT ,  DEPRECATED ,  END_OF_LIFE )
  • the full  lifecycleEvents  list (standard/extended support end, end of life, resource-create/update blocks) with per-event dates, regions, and impact risks
  • a per-event  behavior  block: what actually happens at that milestone ( CHARGES_APPLY ,  AUTO_UPGRADE ,  DOMAIN_ISOLATED ,  RUNS_UNPATCHED ,  CREATE_BLOCKED , and more), including conditional outcomes that depend on a per-resource setting
  •  provenance  (source, confidence, sourceUrl, lastVerified)
The headline change from v1: the dataset now mirrors the native API's event structure and adds the one thing the API cannot express, what happens to your resources when support ends, service by service.

Examples of use cases

  • Upgrade planning and roadmaps - see which versions are approaching or past end of standard support and schedule upgrades before they hit Extended Support.
  • Dashboards and reports - power reporting in any BI tool on lifecycle exposure across the fleet, each date traceable to the AWS Health Version Catalog or a cited AWS page.
  • CI/CD gates - warn or block a pipeline that deploys a runtime or engine version that is end of life or nearing end of support.
  • Change management - feed structured lifecycle dates into approval processes so upgrades are planned ahead of the deadline.
  • Security and compliance - audit the fleet against a "no unsupported versions" policy with citable dates.
  • ITSM integration - auto-raise tickets when a version enters Extended Support or reaches end of life.
  • Fleet and account audits - join your running versions against the lifecycle dates to find exposure.
  • Agents and chatbots - answer "when does X lose support, and what happens if I don't upgrade?" from a structured source with a citation.

Quick start

git clone https://github.com/awslabs/aws-service-eol-data.git
cd aws-service-eol-data

Dates live in events; recompute status at read time

Dates are inside  lifecycleEvents , and  status  is a build-time snapshot. For automated decisions, recompute status from the events:
def status_from_events(events, today):
d = {e["lifecycleEventType"]: e["date"] for e in events if e.get("date")}
se = d.get("STANDARD_SUPPORT_END") or d.get("END_OF_SUPPORT")
ee = d.get("EXTENDED_SUPPORT_END")
eol = d.get("END_OF_LIFE")
if eol and today >= eol:
return "END_OF_LIFE"
if ee:
if today >= ee:
return "END_OF_LIFE"
if se and today >= se:
return "EXTENDED_SUPPORT"
return "STANDARD_SUPPORT"
if se and today >= se:
return "DEPRECATED"
return "STANDARD_SUPPORT"

Example 1: RDS instances approaching end of support

import json, boto3
from datetime import datetime

with open("data/eol.json") as f:
data = json.load(f)
today = datetime.now().strftime("%Y-%m-%d")
lookup = {(e["serviceCode"], e.get("engine"), e["versionNumber"]): e for e in data["entries"]}

rds = boto3.client("rds")
for page in rds.get_paginator("describe_db_instances").paginate():
for db in page["DBInstances"]:
engine = "postgresql" if "postgres" in db["Engine"] else "mysql" if "mysql" in db["Engine"] else db["Engine"]
service_code = "rds-aurora" if db["Engine"].startswith("aurora") else "rds"
major = db["EngineVersion"].split(".")[0] if engine == "postgresql" else ".".join(db["EngineVersion"].split(".")[:2])
info = lookup.get((service_code, engine, major))
if info:
st = status_from_events(info["lifecycleEvents"], today)
if st != "STANDARD_SUPPORT":
print(f"{db['DBInstanceIdentifier']}: {service_code} {engine} {major} is {st}")

Example 2: scan EKS clusters across all regions

import boto3, json
with open("data/eol.json") as f:
data = json.load(f)
eks_versions = {e["versionNumber"]: e for e in data["entries"] if e["serviceCode"] == "eks"}

ec2 = boto3.client("ec2")
for region in [r["RegionName"] for r in ec2.describe_regions()["Regions"]]:
eks = boto3.client("eks", region_name=region)
try:
for name in eks.list_clusters()["clusters"]:
v = eks.describe_cluster(name=name)["cluster"]["version"]
info = eks_versions.get(v, {})
print(name, region, v, info.get("status", "UNKNOWN"))
except Exception:
continue

Example 3: Lambda runtime deprecation check in CI/CD

The Lambda runtime identifier is the raw  version  field:
RUNTIME="$1" # e.g. python3.9
STATUS=$(jq -r --arg rt "$RUNTIME" \
'.entries[] | select(.serviceCode=="lambda" and .version==$rt) | .status' data/eol.json)

if [ -z "$STATUS" ] || [ "$STATUS" = "null" ]; then
echo "BLOCKED: runtime $RUNTIME not found. Cannot verify support."; exit 1
elif [ "$STATUS" = "DEPRECATED" ] || [ "$STATUS" = "END_OF_LIFE" ]; then
echo "BLOCKED: runtime $RUNTIME is $STATUS."; exit 1
else
echo "OK: runtime $RUNTIME is $STATUS."
fi

Example 4: what happens if you don't upgrade

The  behavior  block on each support-end event tells you the real outcome:
for e in data["entries"]:
for ev in e["lifecycleEvents"]:
b = ev.get("behavior")
if b:
outcome = b.get("outcome") or f"{b['default']} (default; depends on {b['conditionalOn']})"
print(f"{e['serviceCode']} {e['versionNumber']} @ {ev['lifecycleEventType']}: {outcome} [{b['sourceUrl']}]")
For example, an OpenSearch version at end of extended support reports  DOMAIN_ISOLATED  (the domain becomes unreachable until you migrate), while RDS and Aurora report  AUTO_UPGRADE , and a deprecated Lambda runtime reports  RUNS_UNPATCHED  (it keeps running indefinitely). The API's generic "no longer available" signal hides those differences; the  behavior  block makes them explicit, each with a documentation link.

Understanding the schema

Each entry answers three questions: when support ends (the  lifecycleEvents  dates), what happens when it ends (the per-event  behavior ), and how we know (the  provenance  and per-behavior  sourceUrl ).
Some behaviors are conditional on a per-resource setting. RDS and Aurora, for instance, branch at end of standard support on whether you left  EngineLifecycleSupport  enabled (auto-enroll in paid Extended Support) or disabled (auto-upgrade). The dataset encodes both branches plus the default, so you can resolve the outcome for your own configuration.
Two things are deliberately not stored, because they are better computed live against first-party sources:
  • Cost is a join to the companion  pricing dataset : each pricing entry's  match  block names the  serviceCode ,  engine , and (where rates differ by version)  versionNumbers  it prices.
  • Bedrock model modality and live status are a join to  bedrock:ListFoundationModels  on  modelId  (which equals a Bedrock entry's  version ). These are region-scoped, so querying your own region gives the accurate answer.

Freshness and accuracy

Dates come from the AWS Health Version Catalog (first-party) or, for documentation-sourced entries, from official docs cited in  provenance.sourceUrl . The dataset is updated monthly on a best-effort basis, sometimes more often. The top-level  generatedAt  tells you when it was last checked against the API, and  lastUpdated  when the data last changed; if  generatedAt  is more than 30 days old, re-verify before acting. For automated decisions, recompute  status  from  lifecycleEvents , check API entries against the service's AWS documentation and documentation-sourced entries against their  provenance.sourceUrl  (API entries have none), and pin to a tagged release.
This is a community-maintained dataset, not an official AWS API. We welcome reports through GitHub Issues: a wrong date or  behavior  outcome, or a version the API does not cover, each with a link to the official AWS documentation.

What's next

The companion Extended Support pricing dataset is available at  aws-service-extended-support-pricing . Together they answer when a version loses support and what it costs to stay on it.

Get involved

  • Contributions welcome: see CONTRIBUTING.md
  • Found an error? Open an issue with the correct value and a source URL
We built this because our customers asked for it. If it saves you time, let us know.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article