Find and Abort Incomplete S3 Multipart Uploads

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ListBuckets",
      "Effect": "Allow",
      "Action": "s3:ListAllMyBuckets",
      "Resource": "*"
    },
    {
      "Sid": "ListUploads",
      "Effect": "Allow",
      "Action": "s3:ListBucketMultipartUploads",
      "Resource": "arn:aws:s3:::*"
    },
    {
      "Sid": "ListParts",
      "Effect": "Allow",
      "Action": "s3:ListMultipartUploadParts",
      "Resource": "arn:aws:s3:::*/*"
    },
    {
      "Sid": "AbortOnlyWithApply",
      "Effect": "Allow",
      "Action": "s3:AbortMultipartUpload",
      "Resource": "arn:aws:s3:::*/*"
    }
  ]
}

// find-incomplete-s3-multipart-uploads.ts
// Lists incomplete multipart uploads in every bucket you own, sums the bytes their parts hold and
// estimates the monthly storage cost. Report only by default. With --apply, aborts the uploads that
// are older than --older-than days (default 7), which deletes their parts.
// Usage:
//   npx tsx find-incomplete-s3-multipart-uploads.ts [--older-than 7] [--bucket my-bucket] [--price 0.023] [--apply]
import {
  AbortMultipartUploadCommand,
  ListMultipartUploadsCommand,
  S3Client,
  paginateListBuckets,
  paginateListParts,
  type MultipartUpload,
} from "@aws-sdk/client-s3";

const args = process.argv.slice(2);
const flag = (name: string): string | undefined => {
  const i = args.indexOf(name);
  return i >= 0 ? args[i + 1] : undefined;
};
const apply = args.includes("--apply");
const olderThanDays = Number(flag("--older-than") ?? "7");
const onlyBucket = flag("--bucket");
// S3 Standard, first 50 TB, us-east-1, USD per GB-month (September 2026). Pass --price for your Region.
const pricePerGb = Number(flag("--price") ?? "0.023");
const GB = 1024 ** 3;

interface Row {
  Bucket: string;
  Key: string;
  Initiated: string;
  AgeDays: number;
  StorageClass: string;
  Parts: number;
  SizeGB: string;
  Action: string;
}

const clients = new Map<string, S3Client>();
const clientFor = (region: string): S3Client => {
  let c = clients.get(region);
  if (!c) {
    c = new S3Client({ region });
    clients.set(region, c);
  }
  return c;
};

// ListMultipartUploads has no paginator in SDK v3, so follow the key and upload ID markers by hand.
async function listUploads(s3: S3Client, bucket: string): Promise<MultipartUpload[]> {
  const uploads: MultipartUpload[] = [];
  let KeyMarker: string | undefined;
  let UploadIdMarker: string | undefined;
  for (;;) {
    const page = await s3.send(new ListMultipartUploadsCommand({ Bucket: bucket, KeyMarker, UploadIdMarker }));
    uploads.push(...(page.Uploads ?? []));
    if (!page.IsTruncated) return uploads;
    KeyMarker = page.NextKeyMarker;
    UploadIdMarker = page.NextUploadIdMarker;
  }
}

async function partsOf(s3: S3Client, bucket: string, u: MultipartUpload): Promise<{ count: number; bytes: number }> {
  let count = 0;
  let bytes = 0;
  for await (const page of paginateListParts({ client: s3 }, { Bucket: bucket, Key: u.Key, UploadId: u.UploadId })) {
    for (const p of page.Parts ?? []) {
      count++;
      bytes += p.Size ?? 0;
    }
  }
  return { count, bytes };
}

async function main(): Promise<void> {
  const home = clientFor(process.env.AWS_REGION ?? "us-east-1");
  const buckets: { name: string; region: string }[] = [];
  // Sending MaxBuckets makes ListBuckets return each bucket's Region (BucketRegion).
  for await (const page of paginateListBuckets({ client: home }, { MaxBuckets: 1000 })) {
    for (const b of page.Buckets ?? []) {
      if (!b.Name || (onlyBucket && b.Name !== onlyBucket)) continue;
      buckets.push({ name: b.Name, region: b.BucketRegion ?? "us-east-1" });
    }
  }

  const rows: Row[] = [];
  let totalBytes = 0;
  let staleBytes = 0;
  for (const { name, region } of buckets) {
    const s3 = clientFor(region);
    try {
      for (const u of await listUploads(s3, name)) {
        const ageDays = u.Initiated ? Math.floor((Date.now() - u.Initiated.getTime()) / 86_400_000) : 0;
        const { count, bytes } = await partsOf(s3, name, u);
        const stale = ageDays >= olderThanDays;
        totalBytes += bytes;
        if (stale) staleBytes += bytes;
        let action = stale ? "would abort" : "keep (recent)";
        if (stale && apply) {
          await s3.send(new AbortMultipartUploadCommand({ Bucket: name, Key: u.Key, UploadId: u.UploadId }));
          action = "ABORTED";
        }
        rows.push({
          Bucket: name,
          Key: (u.Key ?? "").length > 40 ? `...${(u.Key ?? "").slice(-37)}` : u.Key ?? "",
          Initiated: u.Initiated?.toISOString().slice(0, 10) ?? "",
          AgeDays: ageDays,
          StorageClass: u.StorageClass ?? "STANDARD",
          Parts: count,
          SizeGB: (bytes / GB).toFixed(2),
          Action: action,
        });
      }
    } catch (err) {
      console.error(`${name}: ${err instanceof Error ? `${err.name}: ${err.message}` : String(err)}`);
    }
  }

  rows.sort((a, b) => Number(b.SizeGB) - Number(a.SizeGB));
  if (rows.length) console.table(rows);
  const cost = (bytes: number) => ((bytes / GB) * pricePerGb).toFixed(2);
  console.log(`${buckets.length} buckets, ${rows.length} incomplete uploads, ${(totalBytes / GB).toFixed(2)} GB in parts`);
  console.log(`Older than ${olderThanDays} days: ${(staleBytes / GB).toFixed(2)} GB, about $${cost(staleBytes)} per month at $${pricePerGb}/GB`);
  console.log(apply ? "Aborted the uploads marked ABORTED." : "Report only: nothing was modified. Add --apply to abort the old uploads.");
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

npm install @aws-sdk/client-s3
npm install --save-dev tsx typescript @types/node

# Report on every bucket
AWS_PROFILE=readonly npx tsx find-incomplete-s3-multipart-uploads.ts

# Abort uploads older than 14 days in one bucket
AWS_PROFILE=ops npx tsx find-incomplete-s3-multipart-uploads.ts --bucket db-backups-prod --older-than 14 --apply

┌─────────┬───────────────────┬──────────────────────────────┬──────────────┬─────────┬──────────────┬───────┬──────────┬─────────────────┐
│ (index) │ Bucket            │ Key                          │ Initiated    │ AgeDays │ StorageClass │ Parts │ SizeGB   │ Action          │
├─────────┼───────────────────┼──────────────────────────────┼──────────────┼─────────┼──────────────┼───────┼──────────┼─────────────────┤
│ 0       │ 'db-backups-prod' │ 'nightly/2027-03-02/pg.dump' │ '2027-03-02' │ 76      │ 'STANDARD'   │ 3100  │ '310.00' │ 'would abort'   │
│ 1       │ 'media-uploads'   │ 'raw/launch-video-final.mov' │ '2027-04-11' │ 36      │ 'STANDARD'   │ 12    │ '96.00'  │ 'would abort'   │
│ 2       │ 'media-uploads'   │ 'raw/tmp-4f1c.bin'           │ '2027-05-01' │ 16      │ 'STANDARD'   │ 3     │ '6.00'   │ 'would abort'   │
│ 3       │ 'db-backups-prod' │ 'nightly/2027-05-17/pg.dump' │ '2027-05-17' │ 0       │ 'STANDARD'   │ 840   │ '84.00'  │ 'keep (recent)' │
└─────────┴───────────────────┴──────────────────────────────┴──────────────┴─────────┴──────────────┴───────┴──────────┴─────────────────┘
41 buckets, 4 incomplete uploads, 496.00 GB in parts
Older than 7 days: 412.00 GB, about $9.48 per month at $0.023/GB
Report only: nothing was modified. Add --apply to abort the old uploads.