Compare EC2 Spot Price History Across Availability Zones

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ReadSpotAndOnDemandPrices",
      "Effect": "Allow",
      "Action": [
        "ec2:DescribeSpotPriceHistory",
        "pricing:GetProducts"
      ],
      "Resource": "*"
    }
  ]
}

// spot-price-history.ts
// Pulls EC2 Spot price history (up to the last 90 days) for a few instance types in one Region,
// computes a time-weighted average, min, max and latest price per Availability Zone, picks the
// cheapest zone per type and compares it with the On-Demand price from the AWS Price List API.
// Read-only: it never requests or launches Spot capacity.
// Usage: npx tsx spot-price-history.ts [--region us-east-1] [--types m7i.large,c7i.xlarge] [--days 30] [--os "Linux/UNIX"] [--no-on-demand]
import { EC2Client, paginateDescribeSpotPriceHistory, type _InstanceType } from "@aws-sdk/client-ec2";
import { GetProductsCommand, PricingClient } from "@aws-sdk/client-pricing";

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 region = flag("--region") ?? process.env.AWS_REGION ?? "us-east-1";
const types = (flag("--types") ?? "m7i.large,c7i.xlarge").split(",").map((t) => t.trim()).filter(Boolean);
const days = Math.min(Number(flag("--days") ?? 30), 90); // the API only goes back 90 days
const os = flag("--os") ?? "Linux/UNIX";
const withOnDemand = !args.includes("--no-on-demand");

interface Point {
  at: number; // epoch ms
  price: number;
}

interface ZoneStats {
  Type: string;
  Zone: string;
  Avg: number;
  Min: number;
  Max: number;
  Latest: number;
  Changes: number;
}

// Time-weighted average: each price holds until the next change (or until "now").
function stats(type: string, zone: string, points: Point[], from: number, to: number): ZoneStats {
  const sorted = [...points].sort((a, b) => a.at - b.at);
  let weighted = 0;
  let covered = 0;
  sorted.forEach((p, i) => {
    const start = Math.max(p.at, from); // the API also returns the last change before StartTime
    const end = i + 1 < sorted.length ? (sorted[i + 1]?.at ?? to) : to;
    if (end > start) {
      weighted += p.price * (end - start);
      covered += end - start;
    }
  });
  const prices = sorted.map((p) => p.price);
  return {
    Type: type,
    Zone: zone,
    Avg: covered ? weighted / covered : Number.NaN,
    Min: Math.min(...prices),
    Max: Math.max(...prices),
    Latest: sorted[sorted.length - 1]?.price ?? Number.NaN,
    Changes: sorted.length,
  };
}

// On-Demand hourly price for shared-tenancy Linux with no pre-installed software, from the Price List Query API.
async function onDemandPrice(pricing: PricingClient, instanceType: string): Promise<number | undefined> {
  const match = (Field: string, Value: string) => ({ Type: "TERM_MATCH" as const, Field, Value });
  const res = await pricing.send(
    new GetProductsCommand({
      ServiceCode: "AmazonEC2",
      Filters: [
        match("instanceType", instanceType),
        match("regionCode", region),
        match("operatingSystem", "Linux"),
        match("tenancy", "Shared"),
        match("preInstalledSw", "NA"),
        match("capacitystatus", "Used"),
        match("licenseModel", "No License required"),
      ],
      MaxResults: 10,
    }),
  );
  for (const item of res.PriceList ?? []) {
    const product = JSON.parse(item) as {
      terms?: { OnDemand?: Record<string, { priceDimensions?: Record<string, { pricePerUnit?: { USD?: string } }> }> };
    };
    for (const term of Object.values(product.terms?.OnDemand ?? {})) {
      for (const dim of Object.values(term.priceDimensions ?? {})) {
        const usd = Number(dim.pricePerUnit?.USD);
        if (usd > 0) return usd;
      }
    }
  }
  return undefined;
}

async function main(): Promise<void> {
  if (os !== "Linux/UNIX" && withOnDemand) console.log("Note: the On-Demand column is for Linux; pass --no-on-demand for other platforms.");
  const ec2 = new EC2Client({ region });
  const to = Date.now();
  const from = to - days * 24 * 3600 * 1000;

  // type -> zone -> price points
  const series = new Map<string, Map<string, Point[]>>();
  const pages = paginateDescribeSpotPriceHistory(
    { client: ec2 },
    { InstanceTypes: types as _InstanceType[], ProductDescriptions: [os], StartTime: new Date(from), EndTime: new Date(to) },
  );
  for await (const page of pages) {
    for (const p of page.SpotPriceHistory ?? []) {
      if (!p.InstanceType || !p.AvailabilityZone || !p.SpotPrice || !p.Timestamp) continue;
      const zones = series.get(p.InstanceType) ?? new Map<string, Point[]>();
      zones.set(p.AvailabilityZone, [...(zones.get(p.AvailabilityZone) ?? []), { at: p.Timestamp.getTime(), price: Number(p.SpotPrice) }]);
      series.set(p.InstanceType, zones);
    }
  }

  const pricing = new PricingClient({ region: "us-east-1" }); // a Price List Query API endpoint, not the Region you price
  const rows: ZoneStats[] = [];
  const summary: Record<string, string | number>[] = [];
  for (const type of types) {
    const zones = series.get(type);
    if (!zones?.size) {
      console.log(`${type}: no Spot price history for ${os} in ${region} (not offered, or no data in the window)`);
      continue;
    }
    const perZone = [...zones].map(([zone, points]) => stats(type, zone, points, from, to)).sort((a, b) => a.Avg - b.Avg);
    rows.push(...perZone);
    const best = perZone[0];
    const worst = perZone[perZone.length - 1];
    if (!best || !worst) continue;
    const od = withOnDemand ? await onDemandPrice(pricing, type) : undefined;
    summary.push({
      Type: type,
      CheapestZone: best.Zone,
      SpotAvg: best.Avg.toFixed(4),
      PriciestZoneAvg: worst.Avg.toFixed(4),
      OnDemand: od?.toFixed(4) ?? "n/a",
      SavingVsOnDemand: od ? `${Math.round((1 - best.Avg / od) * 100)}%` : "n/a",
      MonthlyAtAvg: (best.Avg * 730).toFixed(2), // 730 hours ≈ 1 month
    });
  }

  console.table(rows.map((r) => ({ ...r, Avg: r.Avg.toFixed(4), Min: r.Min.toFixed(4), Max: r.Max.toFixed(4), Latest: r.Latest.toFixed(4) })));
  console.table(summary);
  console.log(`${os}, ${region}, last ${days} days, USD per instance-hour. Read-only: no Spot request was made.`);
}

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

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

# Two interchangeable types, last 30 days, us-east-1
AWS_PROFILE=readonly npx tsx spot-price-history.ts --region us-east-1 --types m7i.large,m6i.large --days 30

# The full 90 days, Spot only
AWS_PROFILE=readonly npx tsx spot-price-history.ts --region eu-west-1 --types c7i.xlarge --days 90 --no-on-demand

┌─────────┬─────────────┬──────────────┬──────────┬─────────────────┬──────────┬──────────────────┬──────────────┐
│ (index) │ Type        │ CheapestZone │ SpotAvg  │ PriciestZoneAvg │ OnDemand │ SavingVsOnDemand │ MonthlyAtAvg │
├─────────┼─────────────┼──────────────┼──────────┼─────────────────┼──────────┼──────────────────┼──────────────┤
│ 0       │ 'm7i.large' │ 'us-east-1d' │ '0.0391' │ '0.0512'        │ '0.1008' │ '61%'            │ '28.54'      │
│ 1       │ 'm6i.large' │ 'us-east-1b' │ '0.0374' │ '0.0487'        │ '0.0960' │ '61%'            │ '27.30'      │
└─────────┴─────────────┴──────────────┴──────────┴─────────────────┴──────────┴──────────────────┴──────────────┘
Linux/UNIX, us-east-1, last 30 days, USD per instance-hour. Read-only: no Spot request was made.