Find Unused DynamoDB Tables With No Reads or Writes

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ListRegionsTablesAndMetrics",
      "Effect": "Allow",
      "Action": [
        "ec2:DescribeRegions",
        "dynamodb:ListTables",
        "cloudwatch:GetMetricData"
      ],
      "Resource": "*"
    },
    {
      "Sid": "DescribeTables",
      "Effect": "Allow",
      "Action": "dynamodb:DescribeTable",
      "Resource": "arn:aws:dynamodb:*:*:table/*"
    }
  ]
}

// find-unused-dynamodb-tables.ts
// Finds DynamoDB tables with no consumed reads or writes (table plus global secondary indexes) over the
// last N days, in every enabled Region, and estimates what each one costs per month while idle.
// Report only: it never deletes or changes a table.
// Usage: npx tsx find-unused-dynamodb-tables.ts [--regions=us-east-1,eu-west-1] [--days=30]
import { EC2Client, DescribeRegionsCommand } from "@aws-sdk/client-ec2";
import { DynamoDBClient, DescribeTableCommand, paginateListTables } from "@aws-sdk/client-dynamodb";
import { CloudWatchClient, GetMetricDataCommand } from "@aws-sdk/client-cloudwatch";
import type { TableDescription } from "@aws-sdk/client-dynamodb";
import type { MetricDataQuery } from "@aws-sdk/client-cloudwatch";

const args = process.argv.slice(2);
const days = Number(args.find((a) => a.startsWith("--days="))?.split("=")[1] ?? "30");
const regionArg = args.find((a) => a.startsWith("--regions="))?.split("=")[1];

// US East (N. Virginia) list prices, checked September 2026. Other Regions differ; free tier ignored.
const PRICE = {
  storageStandardGb: 0.25,
  storageInfrequentAccessGb: 0.1,
  rcuHour: 0.00013,
  wcuHour: 0.00065,
};
const HOURS_PER_MONTH = 730;

interface Row {
  Region: string;
  Table: string;
  Mode: string;
  SizeGB: string;
  Items: number;
  Reads: number;
  Writes: number;
  Verdict: string;
  IdleUSDPerMonth: string;
}

async function listRegions(): Promise<string[]> {
  if (regionArg) return regionArg.split(",").map((r) => r.trim()).filter(Boolean);
  const out = await new EC2Client({}).send(new DescribeRegionsCommand({})); // enabled Regions only
  return (out.Regions ?? []).map((r) => r.RegionName ?? "").filter(Boolean).sort();
}

// Monthly cost of keeping the table as it is with zero traffic: storage plus provisioned capacity.
function idleMonthlyCost(t: TableDescription): number {
  const gb = (t.TableSizeBytes ?? 0) / 1e9;
  const ia = t.TableClassSummary?.TableClass === "STANDARD_INFREQUENT_ACCESS";
  let cost = gb * (ia ? PRICE.storageInfrequentAccessGb : PRICE.storageStandardGb);
  if (t.BillingModeSummary?.BillingMode !== "PAY_PER_REQUEST") {
    const units = [t.ProvisionedThroughput, ...(t.GlobalSecondaryIndexes ?? []).map((g) => g.ProvisionedThroughput)];
    for (const u of units) {
      cost += (u?.ReadCapacityUnits ?? 0) * PRICE.rcuHour * HOURS_PER_MONTH;
      cost += (u?.WriteCapacityUnits ?? 0) * PRICE.wcuHour * HOURS_PER_MONTH;
    }
  }
  return cost;
}

// One query per table and per GSI, for reads and writes. Ids must start with a lowercase letter.
function queriesFor(t: TableDescription, index: number): MetricDataQuery[] {
  const targets = [undefined, ...(t.GlobalSecondaryIndexes ?? []).map((g) => g.IndexName)];
  const queries: MetricDataQuery[] = [];
  targets.forEach((gsi, j) => {
    for (const metric of ["ConsumedReadCapacityUnits", "ConsumedWriteCapacityUnits"]) {
      const dims = [{ Name: "TableName", Value: t.TableName }];
      if (gsi) dims.push({ Name: "GlobalSecondaryIndexName", Value: gsi });
      queries.push({
        Id: `t${index}_${j}_${metric.includes("Read") ? "r" : "w"}`,
        MetricStat: { Metric: { Namespace: "AWS/DynamoDB", MetricName: metric, Dimensions: dims }, Period: 86400, Stat: "Sum" },
        ReturnData: true,
      });
    }
  });
  return queries;
}

async function sums(cw: CloudWatchClient, queries: MetricDataQuery[]): Promise<Map<string, number>> {
  const totals = new Map<string, number>();
  const end = new Date();
  const start = new Date(end.getTime() - days * 86_400_000);
  for (let i = 0; i < queries.length; i += 500) {
    let NextToken: string | undefined;
    do {
      const out = await cw.send(new GetMetricDataCommand({ MetricDataQueries: queries.slice(i, i + 500), StartTime: start, EndTime: end, NextToken }));
      for (const r of out.MetricDataResults ?? []) {
        const total = (r.Values ?? []).reduce((a, b) => a + b, 0);
        totals.set(r.Id ?? "", (totals.get(r.Id ?? "") ?? 0) + total);
      }
      NextToken = out.NextToken;
    } while (NextToken);
  }
  return totals;
}

async function main(): Promise<void> {
  const rows: Row[] = [];
  for (const region of await listRegions()) {
    const ddb = new DynamoDBClient({ region });
    try {
      const tables: TableDescription[] = [];
      for await (const page of paginateListTables({ client: ddb }, {})) {
        for (const name of page.TableNames ?? []) {
          const { Table } = await ddb.send(new DescribeTableCommand({ TableName: name }));
          if (Table) tables.push(Table);
        }
      }
      if (!tables.length) continue;
      const queries = tables.flatMap((t, i) => queriesFor(t, i));
      const totals = await sums(new CloudWatchClient({ region }), queries);

      tables.forEach((t, i) => {
        let reads = 0;
        let writes = 0;
        for (const [id, value] of totals) {
          if (!id.startsWith(`t${i}_`)) continue;
          if (id.endsWith("_r")) reads += value;
          else writes += value;
        }
        const ageDays = t.CreationDateTime ? (Date.now() - t.CreationDateTime.getTime()) / 86_400_000 : days;
        const verdict = ageDays < days ? "TOO NEW" : reads === 0 && writes === 0 ? "UNUSED" : reads === 0 ? "WRITE ONLY" : "ACTIVE";
        rows.push({
          Region: region,
          Table: t.TableName ?? "?",
          Mode: t.BillingModeSummary?.BillingMode === "PAY_PER_REQUEST" ? "on-demand" : "provisioned",
          SizeGB: ((t.TableSizeBytes ?? 0) / 1e9).toFixed(2),
          Items: t.ItemCount ?? 0,
          Reads: Math.round(reads),
          Writes: Math.round(writes),
          Verdict: verdict + (t.DeletionProtectionEnabled ? " (protected)" : ""),
          IdleUSDPerMonth: idleMonthlyCost(t).toFixed(2),
        });
      });
    } catch (err) {
      rows.push({ Region: region, Table: `ERROR ${err instanceof Error ? err.name : err}`, Mode: "", SizeGB: "", Items: 0, Reads: 0, Writes: 0, Verdict: "", IdleUSDPerMonth: "" });
    }
  }

  const order = ["UNUSED", "WRITE ONLY", "TOO NEW", "ACTIVE"];
  const rank = (v: string) => order.indexOf(v.replace(" (protected)", ""));
  rows.sort((a, b) => rank(a.Verdict) - rank(b.Verdict) || Number(b.IdleUSDPerMonth) - Number(a.IdleUSDPerMonth));
  console.table(rows);

  const unused = rows.filter((r) => r.Verdict.startsWith("UNUSED"));
  const monthly = unused.reduce((sum, r) => sum + Number(r.IdleUSDPerMonth), 0);
  console.log(`${unused.length} table(s) with no reads or writes in ${days} days, about $${monthly.toFixed(2)}/month at us-east-1 list prices.`);
  if (unused.length) process.exitCode = 2;
}

main().catch((err) => {
  console.error(err instanceof Error ? `${err.name}: ${err.message}` : err);
  process.exit(1);
});

npm install @aws-sdk/client-dynamodb @aws-sdk/client-cloudwatch @aws-sdk/client-ec2
npm install --save-dev tsx typescript

# Every enabled Region, last 30 days
AWS_PROFILE=cost-audit npx tsx find-unused-dynamodb-tables.ts

# Two Regions, last 90 days (catches monthly and quarterly jobs)
AWS_PROFILE=cost-audit npx tsx find-unused-dynamodb-tables.ts --regions=us-east-1,eu-west-1 --days=90

┌─────────┬─────────────┬─────────────────────┬───────────────┬─────────┬──────────┬──────────┬─────────┬──────────────────────┬─────────────────┐
│ (index) │ Region      │ Table               │ Mode          │ SizeGB  │ Items    │ Reads    │ Writes  │ Verdict              │ IdleUSDPerMonth │
├─────────┼─────────────┼─────────────────────┼───────────────┼─────────┼──────────┼──────────┼─────────┼──────────────────────┼─────────────────┤
│ 0       │ 'us-east-1' │ 'loadtest-orders'   │ 'provisioned' │ '80.00' │ 41200000 │ 0        │ 0       │ 'UNUSED'             │ '117.27'        │
│ 1       │ 'eu-west-1' │ 'legacy-sessions'   │ 'on-demand'   │ '12.40' │ 3182044  │ 0        │ 0       │ 'UNUSED (protected)' │ '3.10'          │
│ 2       │ 'us-east-1' │ 'audit-events'      │ 'on-demand'   │ '1.20'  │ 912003   │ 0        │ 48213   │ 'WRITE ONLY'         │ '0.30'          │
│ 3       │ 'us-east-1' │ 'migration-staging' │ 'provisioned' │ '0.35'  │ 20511    │ 0        │ 0       │ 'TOO NEW'            │ '2.93'          │
│ 4       │ 'us-east-1' │ 'orders'            │ 'on-demand'   │ '45.10' │ 18733120 │ 88412907 │ 4120554 │ 'ACTIVE (protected)' │ '11.28'         │
└─────────┴─────────────┴─────────────────────┴───────────────┴─────────┴──────────┴──────────┴─────────┴──────────────────────┴─────────────────┘
2 table(s) with no reads or writes in 30 days, about $120.37/month at us-east-1 list prices.