Find Unused Amazon WorkSpaces

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ReadWorkSpaces",
      "Effect": "Allow",
      "Action": [
        "workspaces:DescribeWorkspaces",
        "workspaces:DescribeWorkspacesConnectionStatus"
      ],
      "Resource": "*"
    },
    {
      "Sid": "SwitchRunningModeWithApply",
      "Effect": "Allow",
      "Action": "workspaces:ModifyWorkspaceProperties",
      "Resource": "arn:aws:workspaces:*:123456789012:workspace/*"
    }
  ]
}

// find-unused-amazon-workspaces.ts
// Lists Amazon WorkSpaces Personal desktops whose user hasn't connected for N days (or ever), with running mode,
// compute type and what switching an unused AlwaysOn WorkSpace to AutoStop would save.
// Report only by default. --apply switches unused ALWAYS_ON WorkSpaces to AUTO_STOP. It never terminates anything.
// Usage: npx tsx find-unused-amazon-workspaces.ts [--regions us-east-1,eu-west-1] [--days 30] [--csv workspaces.csv] [--apply]
import { writeFileSync } from "node:fs";
import {
  DescribeWorkspacesConnectionStatusCommand,
  ModifyWorkspacePropertiesCommand,
  WorkSpacesClient,
  paginateDescribeWorkspaces,
  type Workspace,
} from "@aws-sdk/client-workspaces";

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 regions = (flag("--regions") ?? process.env.AWS_REGION ?? "us-east-1").split(",").map((r) => r.trim()).filter(Boolean);
const days = Number(flag("--days") ?? 30);
const csvPath = flag("--csv");
const apply = args.includes("--apply");
const DAY_MS = 86_400_000;

// us-east-1, Windows with license included, default bundle storage. AWS Price List, September 2026.
// [AlwaysOn per month, AutoStop per month, AutoStop per hour]
const PRICE: Record<string, [number, number, number]> = {
  VALUE: [25, 7.25, 0.22],
  STANDARD: [35, 9.75, 0.3],
  PERFORMANCE: [50, 13, 0.47],
  POWER: [78, 19, 0.68],
  POWERPRO: [140, 19, 1.53],
};

interface Row {
  Region: string;
  WorkspaceId: string;
  User: string;
  Compute: string;
  RunningMode: string;
  State: string;
  LastConnected: string;
  IdleDays: number | string;
  SavingPerMonth: string;
  Verdict: string;
  Action: string;
}

/** LastKnownUserConnectionTimestamp per WorkSpace. The API takes at most 25 IDs per call and has no paginator. */
async function lastConnections(ws: WorkSpacesClient, ids: string[]): Promise<Map<string, Date | undefined>> {
  const result = new Map<string, Date | undefined>();
  for (let i = 0; i < ids.length; i += 25) {
    let NextToken: string | undefined;
    do {
      const res = await ws.send(new DescribeWorkspacesConnectionStatusCommand({ WorkspaceIds: ids.slice(i, i + 25), NextToken }));
      for (const s of res.WorkspacesConnectionStatus ?? []) {
        if (s.WorkspaceId) result.set(s.WorkspaceId, s.LastKnownUserConnectionTimestamp);
      }
      NextToken = res.NextToken;
    } while (NextToken);
  }
  return result;
}

async function scanRegion(region: string): Promise<Row[]> {
  const ws = new WorkSpacesClient({ region });
  const workspaces: Workspace[] = [];
  for await (const page of paginateDescribeWorkspaces({ client: ws }, {})) {
    workspaces.push(...(page.Workspaces ?? []));
  }
  if (workspaces.length === 0) return [];
  const connections = await lastConnections(ws, workspaces.map((w) => w.WorkspaceId ?? "").filter(Boolean));
  const now = Date.now();

  const rows: Row[] = [];
  for (const w of workspaces) {
    const id = w.WorkspaceId ?? "";
    const mode = w.WorkspaceProperties?.RunningMode ?? "UNKNOWN";
    const compute = w.WorkspaceProperties?.ComputeTypeName ?? "UNKNOWN";
    const last = connections.get(id);
    const idleDays = last ? Math.floor((now - last.getTime()) / DAY_MS) : undefined;
    const unused = idleDays === undefined || idleDays >= days;
    const price = PRICE[compute];

    let verdict = "in use";
    let saving = "-";
    if (unused && mode === "ALWAYS_ON") {
      verdict = idleDays === undefined ? "NEVER CONNECTED: AlwaysOn" : "UNUSED: AlwaysOn";
      saving = price ? `$${(price[0] - price[1]).toFixed(2)}` : "check pricing";
    } else if (unused && mode === "AUTO_STOP") {
      verdict = idleDays === undefined ? "NEVER CONNECTED: AutoStop" : "UNUSED: AutoStop (base fee only)";
      saving = price ? `$${price[1].toFixed(2)} if removed` : "check pricing";
    } else if (unused) {
      verdict = `UNUSED: ${mode}`;
    }

    const switchable = unused && mode === "ALWAYS_ON" && (w.State === "AVAILABLE" || w.State === "STOPPED");
    let action = switchable ? "would switch to AUTO_STOP (--apply)" : "-";
    if (apply && switchable) {
      try {
        await ws.send(new ModifyWorkspacePropertiesCommand({
          WorkspaceId: id,
          WorkspaceProperties: { RunningMode: "AUTO_STOP", RunningModeAutoStopTimeoutInMinutes: 60 },
        }));
        action = "switched to AUTO_STOP";
      } catch (err) {
        action = `failed: ${err instanceof Error ? err.name : String(err)}`;
      }
    }
    rows.push({
      Region: region,
      WorkspaceId: id,
      User: w.UserName ?? "",
      Compute: compute,
      RunningMode: mode,
      State: w.State ?? "",
      LastConnected: last ? last.toISOString().slice(0, 10) : "never",
      IdleDays: idleDays ?? "-",
      SavingPerMonth: saving,
      Verdict: verdict,
      Action: action,
    });
  }
  return rows;
}

function toCsv(rows: Row[]): string {
  const cols = Object.keys(rows[0] ?? {}) as (keyof Row)[];
  const cell = (v: string | number) => `"${String(v).replace(/"/g, '""')}"`;
  return [cols.join(","), ...rows.map((r) => cols.map((c) => cell(r[c])).join(","))].join("\n") + "\n";
}

async function main(): Promise<void> {
  const rows: Row[] = [];
  for (const region of regions) {
    try {
      rows.push(...(await scanRegion(region)));
    } catch (err) {
      console.error(`${region}: ${err instanceof Error ? `${err.name}: ${err.message}` : String(err)}`);
    }
  }
  if (rows.length === 0) {
    console.log(`No WorkSpaces in ${regions.join(", ")}.`);
    return;
  }
  console.table(rows);
  const alwaysOnUnused = rows.filter((r) => r.Verdict.includes("AlwaysOn"));
  const saving = alwaysOnUnused.reduce((sum, r) => sum + Number(/\$([\d.]+)/.exec(r.SavingPerMonth)?.[1] ?? 0), 0);
  console.log(`${rows.filter((r) => r.Verdict !== "in use").length} of ${rows.length} WorkSpaces unused for ${days}+ days. ` +
    `Switching the ${alwaysOnUnused.length} AlwaysOn ones to AutoStop saves about $${saving.toFixed(2)} a month (us-east-1 prices, from next month).`);
  if (csvPath) {
    writeFileSync(csvPath, toCsv(rows));
    console.log(`Wrote ${rows.length} rows to ${csvPath}`);
  }
}

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

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

# Report only, with a CSV for managers
AWS_PROFILE=readonly npx tsx find-unused-amazon-workspaces.ts --regions us-east-1,eu-west-1 --csv workspaces.csv

# Switch AlwaysOn WorkSpaces unused for 60+ days to AutoStop
AWS_PROFILE=workspaces-admin npx tsx find-unused-amazon-workspaces.ts --regions us-east-1 --days 60 --apply

┌─────────┬─────────────┬────────────────┬─────────────────┬───────────────┬─────────────┬─────────────┬───────────────┬──────────┬────────────────────┬────────────────────────────────────┬───────────────────────────────────────┐
│ (index) │ Region      │ WorkspaceId    │ User            │ Compute       │ RunningMode │ State       │ LastConnected │ IdleDays │ SavingPerMonth     │ Verdict                            │ Action                                │
├─────────┼─────────────┼────────────────┼─────────────────┼───────────────┼─────────────┼─────────────┼───────────────┼──────────┼────────────────────┼────────────────────────────────────┼───────────────────────────────────────┤
│ 0       │ 'us-east-1' │ 'ws-4k2mvy9pq' │ 'a.fernandes'   │ 'STANDARD'    │ 'ALWAYS_ON' │ 'AVAILABLE' │ '2026-09-28'  │ 0        │ '-'                │ 'in use'                           │ '-'                                   │
│ 1       │ 'us-east-1' │ 'ws-7h3tq81zc' │ 'j.okafor'      │ 'PERFORMANCE' │ 'ALWAYS_ON' │ 'AVAILABLE' │ '2026-07-26'  │ 64       │ '$37.00'           │ 'UNUSED: AlwaysOn'                 │ 'would switch to AUTO_STOP (--apply)' │
│ 2       │ 'us-east-1' │ 'ws-9b1xr55kd' │ 'contractor-02' │ 'STANDARD'    │ 'ALWAYS_ON' │ 'AVAILABLE' │ '2026-05-09'  │ 142      │ '$25.25'           │ 'UNUSED: AlwaysOn'                 │ 'would switch to AUTO_STOP (--apply)' │
│ 3       │ 'us-east-1' │ 'ws-2p8wn63ls' │ 'm.chen'        │ 'POWER'       │ 'ALWAYS_ON' │ 'AVAILABLE' │ 'never'       │ '-'      │ '$59.00'           │ 'NEVER CONNECTED: AlwaysOn'        │ 'would switch to AUTO_STOP (--apply)' │
│ 4       │ 'us-east-1' │ 'ws-5r6jd02qa' │ 's.patel'       │ 'STANDARD'    │ 'AUTO_STOP' │ 'STOPPED'   │ '2026-06-24'  │ 96       │ '$9.75 if removed' │ 'UNUSED: AutoStop (base fee only)' │ '-'                                   │
│ 5       │ 'us-east-1' │ 'ws-8c4hz37vf' │ 'l.nowak'       │ 'VALUE'       │ 'AUTO_STOP' │ 'STOPPED'   │ '2026-09-25'  │ 3        │ '-'                │ 'in use'                           │ '-'                                   │
└─────────┴─────────────┴────────────────┴─────────────────┴───────────────┴─────────────┴─────────────┴───────────────┴──────────┴────────────────────┴────────────────────────────────────┴───────────────────────────────────────┘
4 of 6 WorkSpaces unused for 30+ days. Switching the 3 AlwaysOn ones to AutoStop saves about $121.25 a month (us-east-1 prices, from next month).