Skip to content

Cost and the price book

The Cost tab of FinOps → Cost & savings shows what the selected cluster costs at list price and where the money goes. It is read-only: what could be cut is on Savings. From the top:

Card What it shows Who sees it
Where the money went At the top, Current monthly compute (the cluster’s nodes at their hourly rate × 730) and Unpriced nodes (how many could not be priced). Then cost by category over 7 or 30 days, idle, compute cost per day, pod traffic, and every figure that is not priced Everyone who can see the cluster; the compute figures need Nodes; idle needs the whole cluster
Cost by namespace, workload, team or label The one cost table. It opens grouped by namespace, with efficiency and CSV; see chargeback for grouping by team or label. Under it, Storage, load balancers and network prices disks, public IPs and egress Everyone, for the namespaces they can see
Make the figures match your invoice Your Azure bill, read through a connected cloud account, and Datadog and OpenAI spend. See make the figures match your invoice Whole cluster only
Spend outside the cluster Datadog and OpenAI spend, once their integration is on Whole cluster only
Price book, or Prices: from your Azure bill once your bill is read The rates on file, their source and age Everyone; refresh and upload are admin

The cards from Where the money went to Spend outside the cluster need OpenCost turned on in the cluster’s seylo-observability chart. Until it is, each card says so and names the command that turns it on:

Terminal window
helm upgrade seylo-observability oci://ghcr.io/seylo-inc/charts/seylo-observability --version 0.2.22 --namespace seylo-observability --reset-then-reuse-values --set opencost.enabled=true

Cost and Savings share the figures Seylo worked out recently, so moving between them, and opening them again, does not start the work over. A line near the top says how old they are: Figures from 3 min ago · Refresh. Seylo reuses figures for up to 5 minutes. Refresh works them out again now. The tabs of Cost & savings stay loaded while you move between them, so a tab you return to is as you left it.

Nodes are priced one by one, from three facts:

  1. the node’s instance type, from its node.kubernetes.io/instance-type label;
  2. its region, from its topology.kubernetes.io/region label;
  3. an hourly rate for that instance type in that region, from the price book, for the cluster’s own cloud: what your Azure bill says it cost when the subscription is connected, otherwise a rate you uploaded, otherwise the public on-demand list price.

Workloads are charged, as the page says under How it is split, “on every node it ran on, for the larger of what it requested and what it used, of CPU (per core-hour) and memory (per GiB-hour), plus GPUs requested”. OpenCost, running in your cluster, measures each workload’s share of each node; the node’s price comes from the price book.

On Azure, the rest of the bill that a cluster reports is priced too, from Azure’s public Retail Prices API:

  • persistent volumes — managed disks (Premium SSD, Standard SSD and Standard HDD, LRS and ZRS) by size tier, from the StorageClass’s skuName, for the hours their claim existed. A claim mounted by a workload’s pod is that workload’s; one mounted by nobody is its own line;
  • public IP addresses — one Standard public IPv4 address per public LoadBalancer Service, charged to that Service;
  • egress — internet and inter-region transfer by tier, per GB, only when something in your cluster classifies it by where it went (see network traffic below). Transfer between availability zones is not charged: Azure stopped billing it in May 2024;
  • the AKS management fee — once an admin states the cluster’s pricing tier.

On AWS, Google Cloud and Oracle Cloud, Seylo does not read the public lists for disks, addresses and transfer yet. Those are listed as not priced, never priced from Azure’s list.

List prices, on demand. The sentence under Current monthly compute says what that figure leaves out:

COMPUTE ONLY at on-demand rates: excludes storage, egress, load balancers, control-plane fees and any reserved-instance, savings-plan or spot discount you hold. This is not an invoice - it is the figure that changes when a node is added or removed.

Where the money went adds what can be priced on top of compute, and lists what cannot. Neither is your invoice: reservations, savings plans, enterprise agreements and spot discounts are not in any public list. To bring your own prices in, see your own prices. With your Azure bill connected, node rates are what your bill says those machines cost, reservations and savings plans included.

Currency. Rates are in US dollars. The AWS, Oracle and Google refreshes read USD prices only, an uploaded rate is entered as hourlyUsd, and each Azure rate records the currency the API returned in its source line. A rate from your Azure bill uses the US-dollar figure Azure states beside each line of your bill, whatever currency you are billed in; Seylo converts nothing.

Pick Over 7 days or Over 30 days. The card shows:

Figure What it is
Priced over 7d (or 30d) Everything priced in the window. List price, on-demand; not a bill.
CPU + memory Split into CPU, memory and, where present, GPU
Storage, IPs, egress Split into storage, public IPs and egress, plus the AKS fee once the tier is known
Idle Node cost not allocated to any workload. Shown only to people who see the whole cluster
Pod traffic Bytes sent and received, from cAdvisor. Priced by class only when egress is classified

Below them, compute cost per day as a chart, and then the list of everything that is not priced.

Each line names what is not priced, why, what would price it, and — where only you can supply it — the command or control that does, right there on the page. When the thing is set up, the line and its command disappear.

Each carries one of four badges:

Badge Meaning Who acts
Rate not fetched yet (or Fetching now) A public list has the rate and Seylo has not fetched it yet. It is fetching it now; reload in a minute Nobody. Seylo fetches it by itself
Needs your input Only you can supply it: the AKS tier, whether egress is classified, a StorageClass the agent can read You, with the command or control shown
No public price Nothing a cluster reports can be multiplied by a list price Your own billing data
Not built yet A public list exists that Seylo does not read yet Nobody, today. It is not priced from another list

The lines you can meet:

Line Why What to do
Network egress Each namespace’s traffic is measured in bytes, but not where it went: a byte to the internet and a byte to the pod next door cost very different amounts, and cAdvisor cannot tell them apart Nothing in Seylo today. See network traffic
Cluster management fee The AKS pricing tier is an Azure setting that is not visible from inside the cluster An admin chooses Free, Standard or Premium (Long Term Support) in This cluster’s AKS pricing tier on the line itself, or under Admin → Clusters → Edit → Provider metadata. The tier is on the cluster’s Overview in the Azure portal. Saved with your name and audited; the fee is then priced from the public list
N persistent volumes One line per kind of reason, naming the claims: a rate still being fetched; a StorageClass that names no disk SKU or could not be read; Premium SSD v2 and Ultra disks, whose provisioned IOPS and throughput are not on the volume; Azure Files, whose rates Seylo does not fetch A StorageClass the agent can read that names an Azure disk skuName; otherwise your own billing data
Disk transactions and snapshots Standard SSD and HDD disks also bill per 10,000 operations, and snapshots per GB. A cluster reports neither the operation count nor snapshots taken outside it Your own billing data
Shared load balancer AKS puts every LoadBalancer Service’s rules, and the cluster’s outbound rules, on one Azure Standard Load Balancer, billed per rule and per GB processed. A cluster reports neither, so only each Service’s public IP is priced Your own billing data
Storage, public IPs and egress (not Azure) Seylo fetches these list prices for Azure only so far Your own billing data

“Your own billing data” means your cloud’s own bill. These lines stay unpriced on the Cost tab either way. For Azure, connect the subscription as a cloud account: your whole bill, these charges included, is then on the whole-cloud cost dashboards, and your nodes are priced from it. See make the figures match your invoice.

Spot and cheaper machine types are not estimated at all. A spot price changes hour by hour and spot capacity can be taken back, so a saving from it is a forecast, not a price; a cheaper machine type is only a saving if your workloads fit it and your quota allows it.

Seylo shows each namespace’s network traffic in bytes, in and out, from the kubelet’s own counters, and prices none of it. Those counters cannot tell a byte to the internet from a byte to the pod next door, and the two are billed very differently, so a dollar figure would be a guess.

The network-costs collector is no longer offered (4 November 2026). Charts 0.2.10 to 0.2.19 had an opt-in, opencost.networkCosts.enabled, that installed a collector to classify each pod’s egress. Its image is Kubecost’s (IBM): it is not open source and has no published licence for use inside another product, so Seylo stopped installing it. On those charts, leave the value off. Later charts refuse opencost.networkCosts.enabled=true with the reason; set it to false, or remove it, and upgrade again.

Seylo fetches the public rates a cost view needs by itself, at two moments:

  • On first use. When a view finds a node with no rate on file, or an Azure region with no disk, address or bandwidth rates, it fetches exactly those in the background and the page says so. It asks at most once every six hours for the same thing.
  • Daily. Public rates older than 7 days are fetched again, for the machine types and regions already in the book.

The request carries nothing about you: it asks a public price list for a machine type and a region. Rates you uploaded are never touched.

On a Seylo server where automatic fetching is switched off (usually one with restricted outbound access), the page says Automatic price fetching is off on this server and an admin uses Refresh prices instead. Refresh prices at the top of the tab is always there for an admin who wants the rates now.

Seylo detects the cluster’s cloud from each node’s spec.providerID, which is set by the cloud’s own controller. It does not guess from instance-type names. No cloud credentials are involved at any step.

Cloud How node rates get into the price book
Azure (AKS) The public Azure Retail Prices API
AWS (EKS) The public AWS Price List bulk files
Oracle Cloud (OKE) Oracle’s public price list, for fixed shapes. Flex shapes need an upload (see below)
Google Cloud (GKE) Google’s Cloud Billing Catalog, when your Seylo server has a Google pricing key; otherwise upload by hand. Some machine types need an upload (see below). A connected project’s billing export replaces these for the types it shows
Nodes report more than one cloud Not priced. No single price list applies, and pricing half the estate against the wrong cloud would be confidently wrong
No providerID, or an unrecognised one (bare metal, kind, k3s, others) Not priced. There is no public price list to look the machines up in. Upload rates instead

Only on-demand, Linux, shared-tenancy, hourly rates are kept.

  • Azure: reservation, spot, low-priority, dev/test and Windows rows are discarded. When a SKU has several usable rows the cheapest is taken, so a saving is never overstated, and the refresh reports that it chose. If the response contains rows for SKUs that were not asked for, the whole response is discarded and nothing is stored.
  • AWS: reserved terms, dedicated tenancy, other operating systems, bundled licences and capacity-reservation rows are discarded. A region AWS publishes no file for, or one the refresh runs out of time on, stays unpriced and is named.
  • Oracle Cloud: Oracle publishes prices per OCPU, per GB of memory and per GPU, not per machine, and charges the same in every commercial region. Seylo works out a node’s price from them only when the shape’s size is published:
    • fixed shapes such as VM.Standard2.4, BM.Standard.E4.128 and the GPU shapes (VM.GPU.A10.1, BM.GPU.H100.8 and others). A GPU shape is priced per GPU, as Oracle lists it.
    • Flex shapes (VM.Standard.E4.Flex, VM.Standard.E5.Flex, VM.Standard.A1.Flex and the rest) are not priced from the list. Their OCPUs and memory are chosen per node pool and are not in the shape name, and the memory a node reports is slightly below what was configured, so any figure would be a guess. Upload a rate for them instead.
    • For A1 shapes, the price above Oracle’s monthly free allowance is used; the allowance is per tenancy and is not subtracted.
    • Government regions are not in the public list and stay unpriced.
  • Google Cloud: Google publishes a per-vCPU and a per-GiB rate for each machine family and region. Seylo multiplies them by the machine type’s published size: predefined types in the N1 (standard), N2, N2D, E2, C2, C2D, C3 and N4 families, and custom types (n2-custom-4-16384), whose size is in the name.
    • These are list prices before sustained-use and committed-use discounts. Google applies sustained-use discounts automatically to N1, N2, N2D and C2 machines that run most of a month, so for those your invoice can be up to 20–30% lower.
    • Shared-core types (e2-micro, e2-small, e2-medium), types with bundled local SSD (-lssd), bare-metal types, extended memory and families not listed above stay unpriced, with the reason. Upload a rate for them.
    • Fetching needs a Google pricing key on your Seylo server (an API key that reads Google’s public price catalogue — it has no access to your projects). Without one, the page says so and you can upload rates instead.
  1. On Cost, pick the cluster.
  2. Choose Refresh prices at the top of the tab, or Fetch cloud rates on the Price book card (admin). Until Seylo knows the cluster’s cloud, the card’s button reads Fetch rates and the server names the cloud when it answers.
  3. Seylo reads the cluster’s nodes, collects the instance type and region of each, and asks the cloud’s public price list for exactly those — not the whole catalogue.
  4. The notice says how many rates were stored and lists any pair that is still unpriced — for Oracle and Google, with the reason for each.

Upload is offered on the Price book card (admin):

  • for Oracle Cloud and Google Cloud clusters, next to Fetch, for the machines the public list cannot price;
  • for any cluster whose cloud cannot be fetched at all.

Each row needs an instance type, a region and a positive hourly rate in USD, and the upload is filed under the cloud you name — there is no default. Valid rows are stored and invalid rows are listed by number, so a pasted spreadsheet can be corrected rather than resubmitted blind.

For an Oracle Flex shape, the rate is per shape and region, so upload one only when every node of that shape in that region has the same OCPUs and memory. Work it out as OCPUs × Oracle’s OCPU rate + GB × its memory rate for that shape.

On an Azure or AWS cluster the card offers Fetch, not Upload.

Your own prices: agreements, reservations, discounts

Section titled “Your own prices: agreements, reservations, discounts”

A public list price is what anyone pays on demand. If your organisation pays less — an enterprise agreement, reserved instances, savings plans, committed-use discounts — the public figure overstates your cost. There are two ways to bring your own price in:

  • Your Azure bill. Connect the subscription as a cloud account, with the Reader role and no key. Seylo reads what each machine type actually cost you, with reservations and savings plans spread over their hours, and that price wins over an uploaded rate and the public list for the same machine type and region. See your Azure bill.
  • An uploaded rate. A rate your organisation uploads for a machine type and region replaces the public price for that machine, for your organisation only, in every figure on the Cost tab, unless your Azure bill prices it.

Uploaded rates and rates from your Azure bill are private to your organisation; public list prices are shared. A rate fetched from a public list is the same for every customer, so one copy serves everyone. A rate an admin in your organisation uploads is seen by, and costs the clusters of, your organisation only.

The Price book card shows the source, regions, last refresh, SKUs priced and rate range. Source names each origin on file: Your Azure bill, Azure retail, AWS price list, Oracle price list, Google Cloud catalogue or Upload. A rate older than 7 days is flagged stale: on-demand prices move, and the daily refresh replaces it.

Once Seylo has read your Azure bill, the card is titled Prices: from your Azure bill and adds a table of those rates: Machine type, Region, From your bill (per hour) and How it was worked out. Public list prices are used only for types the bill does not show. A rate from the bill is read again every six hours, so it is never flagged stale.

The Cost tab has one cost table, Cost by namespace, workload, team or label. It opens grouped by namespace, over the last 7 days; choose the last hour, 24 hours or 30 days instead, or group by Workload (each Deployment, StatefulSet, Job and so on), a team label, any label or an annotation, up to three levels. Its columns are CPU, memory, GPU, shared, idle, the total and efficiency, and Download CSV saves exactly the rows on screen. Grouping, share idle and the CSV are described under chargeback.

The table’s Storage, Network and Load balancer columns are a dash with the reason, because OpenCost’s own rates for those are defaults. Under the table, Storage, load balancers and network prices them from Seylo’s price book instead, by namespace and over the same window: the disks behind the storage figure, the public IPs, and each namespace’s traffic, with egress by class where it is measured. How it is split states the method.

Which price each node gets. OpenCost measures each workload’s share of each node and prices it with its own node price. Seylo checks every node’s price against the price book — your Azure bill’s rate for that machine type and region, otherwise your uploaded rate, otherwise the public list price — before it is counted:

  • where OpenCost’s price agrees with the book, or comes from your live Azure price sheet, it is used as it is;
  • where it differs, it is rescaled to the book’s price, keeping OpenCost’s split between CPU, memory and GPU;
  • otherwise the node is unpriced, with the reason.

The reason this check exists: without a billing integration, OpenCost substitutes built-in defaults, based on another cloud’s prices, whenever it cannot look a price up, and it does not say when it has. A person who sees the whole cluster sees each node’s line and which price it used.

A node with no rate is unpriced: the time workloads ran on it is shown, marked “+ unpriced”, and is not added to any total. The card names each unpriced node and the reason, for example:

  • the price book has no rate for that machine type and region yet (it is fetched automatically; an Oracle Flex shape always needs an upload);
  • it is a spot node, and the price book holds on-demand prices;
  • the node has no cloud provider ID (on-premises, kind).

Who sees what. You see the namespaces you can see on the Metrics page. A person who sees the whole cluster also gets each node’s price, unclaimed volumes, and idle cost: for each priced node, its price × the hours it ran in the window, minus what was allocated to workloads on it.

Coding agents can ask the same questions with the cost_allocation tool.

A node is unpriced when Seylo has no sourced rate for it. It is shown with a dash and its reason, counted under Unpriced nodes, and left out of every total — never estimated from a similar instance type. When any node is unpriced, the cost figure says it is a floor:

2 of 6 node(s) could not be priced, so this is a FLOOR for compute, not a total.

The reason on each unpriced node is one of:

Reason shown What to do
no node.kubernetes.io/instance-type label The node carries no instance-type label. Managed node pools set it; a self-built node may not
no topology.kubernetes.io/region label Prices differ by region, so none is applied without one
no price on file for <instance type> in <region> Usually fetched within a minute of the first view. If it stays, the notice from Refresh prices says why — an Oracle Flex shape, a Google shared-core type, or a SKU or region the cloud lists under a different name — and you can upload a rate for it

When nothing on the cluster can be priced, Current monthly compute is a dash with No node on this cluster could be priced. Refresh or upload the price book.

Unpriced nodes do not stop the rest of the analysis. Which nodes could be removed, and what pins the others, does not depend on money — see the scale-down report.

Pricing reads Node objects, which are cluster-scoped. On an agent installed namespace-scoped the read is refused, and the tab shows the agent’s refusal instead of a figure. It is never shown as $0.