Find Unused Load Balancers in AWS With No Healthy Targets

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ReadLoadBalancersTargetsAndMetrics",
      "Effect": "Allow",
      "Action": [
        "elasticloadbalancing:DescribeLoadBalancers",
        "elasticloadbalancing:DescribeTargetGroups",
        "elasticloadbalancing:DescribeTargetHealth",
        "cloudwatch:GetMetricData"
      ],
      "Resource": "*"
    }
  ]
}

// find-unused-load-balancers.ts
// Reports Application and Network Load Balancers in one region that have no target groups,
// no registered or healthy targets, or no traffic in the last --days days. Read-only.
// Usage: npx tsx find-unused-load-balancers.ts [--days 14]
import {
  ElasticLoadBalancingV2Client,
  DescribeTargetHealthCommand,
  paginateDescribeLoadBalancers,
  paginateDescribeTargetGroups,
  type LoadBalancer,
} from "@aws-sdk/client-elastic-load-balancing-v2";
import { CloudWatchClient, GetMetricDataCommand, type MetricDataQuery } from "@aws-sdk/client-cloudwatch";

// USD per load balancer-hour, us-east-1, as of September 2026 (ALB and NLB). LCUs are billed on top.
const LB_PER_HOUR = 0.0225;
const HOURS_PER_MONTH = 730;

const elb = new ElasticLoadBalancingV2Client({}); // region from AWS_REGION or your profile
const cw = new CloudWatchClient({});

function arg(name: string): string | undefined {
  const i = process.argv.indexOf(name);
  return i === -1 ? undefined : process.argv[i + 1];
}

// ALB: requests routed to targets plus redirects and fixed responses. NLB: new flows.
async function trafficCount(lb: LoadBalancer, days: number): Promise<number> {
  const dimension = lb.LoadBalancerArn?.split(":loadbalancer/")[1] ?? ""; // app/name/id or net/name/id
  const isAlb = lb.Type === "application";
  const namespace = isAlb ? "AWS/ApplicationELB" : "AWS/NetworkELB";
  const metrics = isAlb ? ["RequestCount", "HTTP_Fixed_Response_Count", "HTTP_Redirect_Count"] : ["NewFlowCount"];
  const queries: MetricDataQuery[] = metrics.map((name, i) => ({
    Id: `m${i}`,
    MetricStat: {
      Metric: { Namespace: namespace, MetricName: name, Dimensions: [{ Name: "LoadBalancer", Value: dimension }] },
      Period: 86_400,
      Stat: "Sum",
    },
  }));
  const end = new Date();
  const res = await cw.send(
    new GetMetricDataCommand({ StartTime: new Date(end.getTime() - days * 86_400_000), EndTime: end, MetricDataQueries: queries }),
  );
  // ELB publishes nothing when there is no traffic, so missing data means zero.
  return (res.MetricDataResults ?? []).flatMap((r) => r.Values ?? []).reduce((s, v) => s + v, 0);
}

async function targets(lbArn: string) {
  let groups = 0;
  let registered = 0;
  let healthy = 0;
  for await (const page of paginateDescribeTargetGroups({ client: elb }, { LoadBalancerArn: lbArn })) {
    for (const tg of page.TargetGroups ?? []) {
      groups++;
      const health = await elb.send(new DescribeTargetHealthCommand({ TargetGroupArn: tg.TargetGroupArn }));
      for (const d of health.TargetHealthDescriptions ?? []) {
        registered++;
        if (d.TargetHealth?.State === "healthy") healthy++;
      }
    }
  }
  return { groups, registered, healthy };
}

async function main(): Promise<void> {
  const days = Number(arg("--days") ?? 14);
  const lbs: LoadBalancer[] = [];
  for await (const page of paginateDescribeLoadBalancers({ client: elb }, {})) {
    lbs.push(...(page.LoadBalancers ?? []));
  }
  const checked = lbs.filter((lb) => lb.Type === "application" || lb.Type === "network");
  if (checked.length === 0) {
    console.log("No Application or Network Load Balancers in this region.");
    return;
  }

  const rows = [];
  let unusedCost = 0;
  for (const lb of checked) {
    const t = await targets(lb.LoadBalancerArn ?? "");
    const traffic = await trafficCount(lb, days);
    const reasons: string[] = [];
    if (t.groups === 0 && traffic === 0) reasons.push("no target groups");
    else if (t.groups > 0 && t.registered === 0) reasons.push("no registered targets");
    else if (t.groups > 0 && t.healthy === 0) reasons.push("no healthy targets");
    if (traffic === 0) reasons.push(`no traffic in ${days}d`);
    // An ALB with no target groups but traffic is serving redirects or fixed responses.
    const inUse = t.groups === 0 && traffic > 0 ? "in use (redirects/fixed responses only)" : "in use";
    const fixed = LB_PER_HOUR * HOURS_PER_MONTH;
    if (reasons.length > 0) unusedCost += fixed;
    rows.push({
      Name: lb.LoadBalancerName ?? "",
      Type: lb.Type === "application" ? "ALB" : "NLB",
      Scheme: lb.Scheme ?? "",
      Created: lb.CreatedTime?.toISOString().slice(0, 10) ?? "",
      TGs: t.groups,
      Targets: t.registered,
      Healthy: t.healthy,
      [`Traffic (${days}d)`]: traffic,
      "Hourly $/mo": fixed.toFixed(2),
      Verdict: reasons.length > 0 ? `REVIEW: ${reasons.join(", ")}` : inUse,
    });
  }
  const flagged = (v: string) => (v.startsWith("REVIEW") ? 0 : 1);
  rows.sort((a, b) => flagged(a.Verdict) - flagged(b.Verdict));
  console.table(rows);
  const skipped = lbs.length - checked.length;
  if (skipped > 0) console.log(`${skipped} Gateway Load Balancers not checked.`);
  console.log(`Flagged load balancers: about $${unusedCost.toFixed(2)}/month in hourly charges, before LCUs.`);
  console.log("Report only: nothing was changed. Check DNS records and listeners before deleting anything.");
}

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

npm install @aws-sdk/client-elastic-load-balancing-v2 @aws-sdk/client-cloudwatch
npm install --save-dev tsx typescript

AWS_PROFILE=readonly AWS_REGION=us-east-1 npx tsx find-unused-load-balancers.ts

# A 30-day window for load balancers that only see monthly traffic
AWS_PROFILE=readonly AWS_REGION=us-east-1 npx tsx find-unused-load-balancers.ts --days 30

┌─────────┬────────────────────┬───────┬───────────────────┬──────────────┬─────┬─────────┬─────────┬───────────────┬─────────────┬───────────────────────────────────────────────────────┐
│ (index) │ Name               │ Type  │ Scheme            │ Created      │ TGs │ Targets │ Healthy │ Traffic (14d) │ Hourly $/mo │ Verdict                                               │
├─────────┼────────────────────┼───────┼───────────────────┼──────────────┼─────┼─────────┼─────────┼───────────────┼─────────────┼───────────────────────────────────────────────────────┤
│ 0       │ 'legacy-api-alb'   │ 'ALB' │ 'internet-facing' │ '2023-05-09' │ 1   │ 0       │ 0       │ 0             │ '16.43'     │ 'REVIEW: no registered targets, no traffic in 14d'    │
│ 1       │ 'staging-web'      │ 'ALB' │ 'internet-facing' │ '2025-11-20' │ 2   │ 2       │ 0       │ 1287          │ '16.43'     │ 'REVIEW: no healthy targets'                          │
│ 2       │ 'k8s-ingress-old'  │ 'NLB' │ 'internal'        │ '2024-02-14' │ 0   │ 0       │ 0       │ 0             │ '16.43'     │ 'REVIEW: no target groups, no traffic in 14d'         │
│ 3       │ 'prod-web'         │ 'ALB' │ 'internet-facing' │ '2022-08-30' │ 3   │ 6       │ 6       │ 48211904      │ '16.43'     │ 'in use'                                              │
│ 4       │ 'http-to-https'    │ 'ALB' │ 'internet-facing' │ '2022-08-30' │ 0   │ 0       │ 0       │ 90214         │ '16.43'     │ 'in use (redirects/fixed responses only)'             │
└─────────┴────────────────────┴───────┴───────────────────┴──────────────┴─────┴─────────┴─────────┴───────────────┴─────────────┴───────────────────────────────────────────────────────┘
Flagged load balancers: about $49.28/month in hourly charges, before LCUs.
Report only: nothing was changed. Check DNS records and listeners before deleting anything.