Home › Learn › Databricks compute and cost › How billing works
Databricks compute and cost · data engineering
How Databricks billing works: DBUs, two invoices, SKUs, autoscaling and billing tracing
The DBU formula, classic versus serverless invoices, illustrative rates and worked examples, SKU families, what autoscaling does to cost and what you can see, and why people say they need classic for billing tracing.
Prices, defaults, limits and preview status change often, and dollar figures here are illustrations. Check the current Databricks documentation and price list before quoting a number.
Billing
How Databricks charges you: the formula and the two invoices
Everything on Databricks compute is priced by one formula:
Databricks charge = DBUs used × price per DBU.
A DBU (Databricks Unit) is a unit of processing per hour. A machine or warehouse "burns" a fixed number of DBUs per hour depending on its type and size. The price per DBU depends on the product (SKU), your plan tier (Premium or Enterprise), the cloud, the region and your contract.
What changes between classic and serverless is what else you pay for separately.
What else is billed
- Per-second billing. Classic VMs and DBUs are billed per second while the cluster is up. Starting, running, idle and waiting-to-terminate all count.
- Pool VMs. Idle VMs in a pool cost you cloud money but no DBUs.
- Photon. On classic clusters Photon raises the DBU rate for those machines. Serverless and SQL warehouses already include it.
- Other products with their own units. Model serving (per hour or per token), Vector Search, Lakebase databases, pipelines, predictive optimization, and so on. Each is its own SKU family (see SKU families).
- Commit discounts. Large customers buy a committed spend with a negotiated discount. The invoice reflects it. Some system tables only show list prices (see what is hidden).
Billing
Rates and worked examples
Treat every dollar figure below as an illustration. Databricks list prices change, and differ by cloud, region, tier (Premium or Enterprise) and contract. I wrote these from memory of typical AWS Premium US list prices. Check the official pricing page before quoting any of them to anyone.
| Product (SKU family) | Illustrative list rate per DBU | Includes VMs? |
|---|---|---|
| Jobs compute (classic job cluster) | about $0.15 | No, plus your cloud VMs |
| All-purpose compute (classic interactive cluster) | about $0.55 | No, plus your cloud VMs |
| Classic SQL warehouse | about $0.22 | No, plus your cloud VMs |
| Pro SQL warehouse | about $0.55 | No, plus your cloud VMs |
| Serverless SQL warehouse | about $0.70 | Yes |
| Serverless jobs / notebooks | roughly $0.35 to $0.95 depending on product and mode | Yes |
| Pipelines (Lakeflow / DLT) Core, Pro, Advanced | about $0.20, $0.25, $0.36 on classic | No on classic, yes on serverless |
SQL warehouse size decides DBUs per hour. Typical figures, each step about double:
| Size | 2X-Small | X-Small | Small | Medium | Large | X-Large | 2X-Large | 3X-Large | 4X-Large |
|---|---|---|---|---|---|---|---|---|---|
| DBU per hour (per cluster) | 4 | 6 | 12 | 24 | 40 | 80 | 144 | 272 | 528 |
A classic cluster's DBUs per hour come from the machine types: each VM type has a fixed DBU rating per hour (for example, a mid-size general-purpose VM is roughly 1 to 2 DBU per hour). The cluster rate is the sum over the driver and all workers.
Three worked examples (illustrative numbers)
Assumptions: each node is a VM rated 2 DBU/hour that costs $0.384/hour on the cloud. Jobs rate $0.15, all-purpose $0.55, serverless SQL $0.70.
| Case | Databricks part | Cloud VM part | Total for 2 hours |
|---|---|---|---|
| A. Nightly job cluster: 1 driver + 4 workers = 5 nodes, 2 hours | 5 × 2 DBU × 2 h = 20 DBU × $0.15 = $3.00 | 5 × $0.384 × 2 h = $3.84 | $6.84 |
| B. Same machines, but on an all-purpose cluster | 20 DBU × $0.55 = $11.00 | $3.84 | $14.84 |
| C. Serverless SQL warehouse, Medium (24 DBU/h), 2 hours | 48 DBU × $0.70 = $33.60 | included | $33.60 |
Do not read C as "serverless is five times worse". The comparison that matters is cost per finished task. Case A also pays for several minutes of boot time before it does any work, idle time waiting to terminate, and VMs that sit half used. A serverless warehouse starts in seconds, stops after a short idle time, and Photon plus Predictive IO often cuts the run time. The honest method is to run the same real workload on both and compare the invoices.
Billing
How many SKUs?
There is no honest single number. A SKU is a billing line, and Databricks creates separate SKUs for each product, plan tier (Premium, Enterprise), cloud, and for many serverless products, each region. On one cloud it is in the order of a hundred or more, and across all clouds, regions and tiers the price list holds several hundred rows. You can count your own exactly:
SELECT COUNT(DISTINCT sku_name) FROM system.billing.list_prices;
And to see only what you actually used: SELECT DISTINCT sku_name FROM system.billing.usage;
Learn them as families, which is how they are named:
| Family | Example SKU name pattern | Meaning |
|---|---|---|
| Classic jobs | PREMIUM_JOBS_COMPUTE, ..._(PHOTON) | Job clusters, with or without Photon |
| Classic all-purpose | PREMIUM_ALL_PURPOSE_COMPUTE, ..._(PHOTON) | Interactive clusters |
| SQL | PREMIUM_SQL_COMPUTE, pro and classic variants | Classic and Pro SQL warehouses |
| Serverless SQL | PREMIUM_SERVERLESS_SQL_COMPUTE_<REGION> | Serverless warehouses. Rate depends on region. |
| Serverless jobs / notebooks | JOBS_SERVERLESS_COMPUTE_<REGION> and similar | Serverless workflows and notebooks |
| Pipelines | DLT_CORE/PRO/ADVANCED_COMPUTE, serverless variants | Lakeflow / Delta Live Tables |
| AI and serving | model serving, foundation model, vector search, AI gateway SKUs | Billed by hour, token or request |
| Databases and platform | Lakebase, predictive optimization, data sharing, networking SKUs | Each its own meter |
The names above show the patterns. Exact strings change, so always read them from system.billing.list_prices rather than trusting a doc.
Billing
Autoscaling and what it does to cost
Autoscaling means the cluster grows and shrinks between a minimum and a maximum. Cost follows the number of nodes at each moment. A cluster with min 2 and max 10 workers that sits at 8 workers most of the day costs four times a fixed 2-worker cluster, even though your "cluster size" setting looks small.
| Compute | How it scales | Is the scaling visible to you? |
|---|---|---|
| Classic cluster | Workers added or removed within min and max | Yes, with work. The cluster event log shows RESIZING events with the target worker count. system.compute.node_timeline gives per-minute utilisation per node. system.compute.clusters shows config changes. But system.billing.usage is hourly per cluster, so you must stitch events and billing together to see which minutes cost what. |
| Classic / Pro / Serverless SQL warehouse | Adds or removes whole clusters between min and max | Yes. system.compute.warehouse_events records starting, running, scaled up, scaled down and stopping with the cluster count. |
| Serverless jobs, notebooks, pipelines | Databricks decides, you cannot see it | No. You see DBUs consumed and run duration. You do not see node counts, node types or scale decisions. This is a real visibility gap. |
So your point is right for serverless, and half right for classic. Classic gives you the raw events but not a ready-made "cost of this scale-up" number. Serverless gives you the DBU total but no scaling history at all.
Practical consequences: on classic, check "peak workers" and "average workers" per job and compare with min and max. On serverless, compare DBU per run over time and treat a rising trend as the only signal of over-scaling.
Billing
Why people insist on classic "for billing tracing"
The claim has a true core and an outdated shell. The true core: on classic compute, cost can be traced in two places that agree with each other, and at machine level.
| Reason people give | Still true today? |
|---|---|
| Cloud bill (AWS Cost Explorer, Azure Cost Management) shows VMs tagged per cluster, so finance can reconcile against Databricks. | True. Serverless has no VMs in your account to tag. |
| Per-cluster granularity: one cluster per team makes cost obvious. | True, and a cluster is a natural unit. Serverless jobs and notebooks have no such object. |
| You can see machine utilisation and prove whether you are wasting money. | True on classic. Not available on serverless. |
| Serverless notebooks could not be tagged per team. | Largely outdated. Serverless budget policies now let an admin attach tags to all serverless usage of a user, group or service principal, and those tags appear in system.billing.usage. Warehouses and jobs can also carry tags. |
| Show a Databricks cost and a cloud cost side by side to justify a commit. | True. With serverless you only have the Databricks number, so you cannot see the split between Databricks margin and the machine cost inside it. |
My reading: classic is the better choice when finance demands a machine-level, two-bill audit trail. For most teams, serverless with budget policies and tagged warehouses is enough, and the tracing gap is smaller than the idle and boot waste classic carries.
FAQ
Questions people ask
How is Databricks billed?
Databricks charge = DBUs used x price per DBU. On classic compute you also pay your cloud for VMs, disks and network. On serverless the machines are inside a higher DBU price.
Why do people say they need classic for billing tracing?
Tags on a classic cluster reach both the Databricks usage records and the cloud's VM costs, so you can reconcile two bills at machine level. Serverless has no VMs of yours to tag, though budget policies now tag serverless usage in the usage table.
Can I see autoscaling in the bill?
Partly. Classic gives event logs and per-minute node data but billing is hourly, so you stitch them. Warehouses have scale events. Serverless jobs and notebooks show no scaling detail, only DBUs.
Next
Where to go next
Related on this site: Tagging best practices · Biggest cost and performance levers · Databricks cost calculator · Cost and FinOps for the platform
All Databricks compute and cost pages · All data engineering · Databricks on this site