/

Data

How to reduce Snowflake costs: a guide for data teams

How to reduce Snowflake costs: a guide for data teams

Data

Data

Mahesh Chandran

Mahesh Chandran

CEO

CEO

Guide cover: How to reduce Snowflake costs. Find where the credits go, then stop paying for work nobody needs.

How much of last month’s Snowflake bill paid for warehouses that were running with no query to run? Snowflake records the answer for every warehouse, hour by hour, and one query returns it.

Idle time is usually the first place to look when a team sets out to reduce Snowflake costs, and it is rarely the last. Credits also go to warehouses sized for a workload that has since shrunk, to tables refreshed every hour for readers who look once a week, and to storage held for recovery that nobody plans to use.

This guide shows where Snowflake spend goes, how to find the warehouses, queries and tables behind it with the ACCOUNT_USAGE views every account already has, and which changes cut the bill without slowing down the work the business depends on. Each fix comes with the setting or query that applies it.

The short answer

Most Snowflake spend is compute, billed in credits while virtual warehouses run. To reduce Snowflake costs, measure how much of each warehouse’s running time is idle and set auto-suspend to match, size each warehouse to the work it does, stop refreshing tables that nobody reads, keep short-lived tables out of Fail-safe, and give every warehouse a credit limit. Start with the warehouses that bill the most credits, because a change there moves the total.

Key terms

  • Credit: the unit Snowflake bills compute in. A warehouse uses credits for every second it runs, and the price of a credit depends on the contract and region.

  • Virtual warehouse: a cluster of compute that runs queries and loads. Its size sets how many credits it uses per hour.

  • Auto-suspend: the number of seconds a warehouse waits with no work before it stops billing.

  • Idle time: time a warehouse runs with no query executing. Snowflake bills it like any other running time.

  • Serverless features: work Snowflake runs on its own compute, such as automatic clustering, Snowpipe and materialized view refreshes, billed separately from warehouses.

  • Cloud services: the layer that handles logins, query planning and metadata. It is billed only when its daily use goes above 10% of daily warehouse use.

  • Time Travel and Fail-safe: two periods during which Snowflake keeps changed and deleted data for recovery. Both add to storage.

  • Resource monitor: a credit limit on one or more warehouses that can notify people or suspend the warehouses when it is reached.

The method at a glance

  1. Rank warehouses by the credits they used over the last 30 days.

  2. Measure idle credits on each warehouse and set auto-suspend to match the workload.

  3. Find the most expensive recurring queries and test the warehouses that run them one size down.

  4. Match each table’s refresh schedule to how much the business depends on it, and retire what nobody reads.

  5. Cut storage held for Time Travel and Fail-safe on tables that can be rebuilt.

  6. Put a resource monitor or budget on every warehouse, and compare the numbers each month.

Where does Snowflake spend go?

A Snowflake bill has two main parts. Compute covers warehouses, serverless features and cloud services, and it is billed in credits. Storage covers the data kept in tables and stages, billed on its compressed size. Data moved between regions or clouds adds a third, usually smaller, line.

What a Snowflake bill is made of: compute billed in credits for warehouses, serverless features and cloud services, and storage billed on compressed size for active data, Time Travel and Fail-safe.

Warehouses are the part a data team controls most directly. An X-Small warehouse uses 1 credit per hour, and each size up roughly doubles the credits billed per hour, so a 4X-Large uses 128. Billing is per second, with a 60-second minimum each time a warehouse starts or resumes. A suspended warehouse uses no credits at all.

Serverless features run on compute that Snowflake manages. They are billed per second of compute time, and each feature has its own rate in the Snowflake Service Consumption Table. Automatic clustering, Snowpipe and materialized view refreshes are the ones most teams run into.

Cloud services cost nothing on most days. Snowflake charges for them only when their daily use goes above 10% of the day’s warehouse use, and serverless compute does not count toward that 10%.

Storage includes more than the current version of each table. Snowflake also bills for historical data kept for Time Travel and Fail-safe, and for files sitting in stages.

The split differs from one account to the next, so check it before deciding where to start. The METERING_DAILY_HISTORY view shows the credits actually billed each day, with the cloud services adjustment already applied. This query totals the last 30 days by service type:

SELECT service_type,
       SUM(credits_billed) AS credits_billed
FROM snowflake.account_usage.metering_daily_history
WHERE usage_date >= DATEADD(day, -30, CURRENT_DATE())
GROUP BY service_type
ORDER BY credits_billed DESC

SELECT service_type,
       SUM(credits_billed) AS credits_billed
FROM snowflake.account_usage.metering_daily_history
WHERE usage_date >= DATEADD(day, -30, CURRENT_DATE())
GROUP BY service_type
ORDER BY credits_billed DESC

SELECT service_type,
       SUM(credits_billed) AS credits_billed
FROM snowflake.account_usage.metering_daily_history
WHERE usage_date >= DATEADD(day, -30, CURRENT_DATE())
GROUP BY service_type
ORDER BY credits_billed DESC

To see the same figures in dollars, Snowflake’s USAGE_IN_CURRENCY_DAILY view converts credits at each day’s credit price.

Which warehouses and queries cost the most?

Two ACCOUNT_USAGE views answer most of this. Both are read-only, and both are available to the ACCOUNTADMIN role by default.

Credits and idle time by warehouse

The WAREHOUSE_METERING_HISTORY view records the credits each warehouse used per hour. Its CREDITS_ATTRIBUTED_COMPUTE_QUERIES column counts only the credits spent running queries, so the difference between the two columns is the cost of idle time. This query lists every warehouse by the credits it used over the last 30 days, with the idle share next to it:

SELECT warehouse_name,
       SUM(credits_used_compute) AS compute_credits,
       SUM(credits_used_compute)
         - SUM(credits_attributed_compute_queries) AS idle_credits,
       ROUND(100 * DIV0(SUM(credits_used_compute)
         - SUM(credits_attributed_compute_queries),
         SUM(credits_used_compute)), 1) AS idle_pct
FROM snowflake.account_usage.warehouse_metering_history
WHERE start_time >= DATEADD(day, -30, CURRENT_DATE())
  AND end_time < CURRENT_DATE()
GROUP BY warehouse_name
ORDER BY compute_credits DESC

SELECT warehouse_name,
       SUM(credits_used_compute) AS compute_credits,
       SUM(credits_used_compute)
         - SUM(credits_attributed_compute_queries) AS idle_credits,
       ROUND(100 * DIV0(SUM(credits_used_compute)
         - SUM(credits_attributed_compute_queries),
         SUM(credits_used_compute)), 1) AS idle_pct
FROM snowflake.account_usage.warehouse_metering_history
WHERE start_time >= DATEADD(day, -30, CURRENT_DATE())
  AND end_time < CURRENT_DATE()
GROUP BY warehouse_name
ORDER BY compute_credits DESC

SELECT warehouse_name,
       SUM(credits_used_compute) AS compute_credits,
       SUM(credits_used_compute)
         - SUM(credits_attributed_compute_queries) AS idle_credits,
       ROUND(100 * DIV0(SUM(credits_used_compute)
         - SUM(credits_attributed_compute_queries),
         SUM(credits_used_compute)), 1) AS idle_pct
FROM snowflake.account_usage.warehouse_metering_history
WHERE start_time >= DATEADD(day, -30, CURRENT_DATE())
  AND end_time < CURRENT_DATE()
GROUP BY warehouse_name
ORDER BY compute_credits DESC

Work on the warehouses at the top of this list first. A high idle share on a large warehouse is the quickest saving in this guide. The view can lag by up to three hours, and the query-attributed column is empty for adaptive warehouses.

Credits by recurring query

The QUERY_ATTRIBUTION_HISTORY view assigns warehouse credits to individual queries over the last 365 days. Grouping by the parameterized query hash adds up every run of the same query, which is how a scheduled job shows its real monthly cost:

SELECT query_parameterized_hash,
       warehouse_name,
       COUNT(*)                         AS runs,
       SUM(credits_attributed_compute)  AS credits,
       ANY_VALUE(query_id)              AS example_query_id
FROM snowflake.account_usage.query_attribution_history
WHERE start_time >= DATEADD(day, -30, CURRENT_DATE())
GROUP BY query_parameterized_hash, warehouse_name
ORDER BY credits DESC
LIMIT 25

SELECT query_parameterized_hash,
       warehouse_name,
       COUNT(*)                         AS runs,
       SUM(credits_attributed_compute)  AS credits,
       ANY_VALUE(query_id)              AS example_query_id
FROM snowflake.account_usage.query_attribution_history
WHERE start_time >= DATEADD(day, -30, CURRENT_DATE())
GROUP BY query_parameterized_hash, warehouse_name
ORDER BY credits DESC
LIMIT 25

SELECT query_parameterized_hash,
       warehouse_name,
       COUNT(*)                         AS runs,
       SUM(credits_attributed_compute)  AS credits,
       ANY_VALUE(query_id)              AS example_query_id
FROM snowflake.account_usage.query_attribution_history
WHERE start_time >= DATEADD(day, -30, CURRENT_DATE())
GROUP BY query_parameterized_hash, warehouse_name
ORDER BY credits DESC
LIMIT 25

Look up each example_query_id in QUERY_HISTORY to see the SQL and the user or tool that ran it. Three limits apply. The view leaves out idle time, it skips queries that run in about 100 milliseconds or less, and it can lag by several hours.

The result is a short list of expensive warehouses and the recurring queries inside them. The next sections work through what to change.

How do you stop paying for idle warehouses?

Auto-suspend decides how long a warehouse keeps billing after its last query finishes. Snowflake’s own guidance notes that the default is 600 seconds, and suggests 60 seconds for workloads that run infrequently. A warehouse used by a nightly job and the occasional analyst can sit idle for close to ten minutes after every query on the default setting.

The same two-minute query on two auto-suspend settings. At 600 seconds the warehouse bills ten idle minutes. At 60 seconds it bills one.
ALTER WAREHOUSE transform_wh SET AUTO_SUSPEND = 60
ALTER WAREHOUSE transform_wh SET AUTO_SUSPEND = 60
ALTER WAREHOUSE transform_wh SET AUTO_SUSPEND = 60

Sixty seconds is also the floor that makes sense. Every resume starts a new 60-second minimum, so a lower setting saves nothing, and a warehouse that suspends and resumes within a minute is billed for each start. A warehouse serving dashboards that refresh every few minutes can cost less with a longer setting, because it avoids paying that minimum on every refresh. Compare idle credits before and after each change using the query above.

Two more settings keep the change in place. Turn on auto-resume wherever auto-suspend is on, so the next query starts the warehouse without anyone stepping in. And limit the MODIFY privilege on warehouses, since anyone who holds it can turn auto-suspend off or resize the warehouse. Snowflake’s documentation includes a query that lists warehouses with auto-suspend disabled, which is worth running every month.

How do you size warehouses for the work they do?

A bigger warehouse costs more per hour and often finishes sooner. Snowflake notes that most queries, particularly larger and more complex ones, scale roughly linearly with warehouse size. For those queries, doubling the size halves the run time, and the credits stay about the same. For small queries the extra compute sits unused, and the bill doubles.

Credits per hour by Gen1 standard warehouse size, from 1 for X-Small to 128 for 4X-Large.

Test sizing on the expensive recurring queries from the attribution query. Run one on its current warehouse and on a warehouse one size smaller, then compare credits and run time in QUERY_ATTRIBUTION_HISTORY. If the smaller warehouse finishes within the time the job allows, move the job.

A few other patterns cost more than they need to:

  • Loading on a large warehouse. Snowflake notes that data loading speed depends more on the number and size of files than on warehouse size, so loads rarely need more than a small warehouse.

  • Using multi-cluster warehouses for slow queries. Extra clusters help when many queries queue at once. They do not speed up a single slow query, and each running cluster bills at the full rate for its size. Where queueing is acceptable, the ECONOMY scaling policy starts extra clusters less readily than the STANDARD default.

  • One warehouse for everything. When loads, transformations and dashboards share a warehouse, it has to be sized for the heaviest of them. Separate warehouses let each one be sized and suspended on its own schedule, and their credits show up separately in the metering views.

How do you stop refreshing data nobody reads?

Every scheduled refresh costs credits whether or not anyone reads the result. A table rebuilt every hour runs about 720 times a month. Moving it to a daily refresh cuts that to about 30.

The question is which tables can take a slower schedule, and which can stop altogether. Two earlier guides cover this in detail. How to find and retire unused data pipelines includes a Snowflake query that lists tables written in the last 90 days and never read. How to decide which datasets your business depends on ranks the rest into tiers, so that Tier 1 data keeps its fast refresh and Tier 3 data moves to a slower one. Snowflake’s Optimization insights also flag large tables that have not been queried recently.

Serverless features need the same check. Automatic clustering and materialized views keep spending credits on tables whose readers left long ago. This query lists the tables that used the most automatic clustering credits in the last 30 days:

SELECT database_name,
       schema_name,
       table_name,
       SUM(credits_used) AS clustering_credits
FROM snowflake.account_usage.automatic_clustering_history
WHERE start_time >= DATEADD(day, -30, CURRENT_DATE())
GROUP BY database_name, schema_name, table_name
ORDER BY clustering_credits DESC
LIMIT 25

SELECT database_name,
       schema_name,
       table_name,
       SUM(credits_used) AS clustering_credits
FROM snowflake.account_usage.automatic_clustering_history
WHERE start_time >= DATEADD(day, -30, CURRENT_DATE())
GROUP BY database_name, schema_name, table_name
ORDER BY clustering_credits DESC
LIMIT 25

SELECT database_name,
       schema_name,
       table_name,
       SUM(credits_used) AS clustering_credits
FROM snowflake.account_usage.automatic_clustering_history
WHERE start_time >= DATEADD(day, -30, CURRENT_DATE())
GROUP BY database_name, schema_name, table_name
ORDER BY clustering_credits DESC
LIMIT 25

Check each table on the list against its read history. Clustering a table nobody queries speeds up nothing. The MATERIALIZED_VIEW_REFRESH_HISTORY view gives the same breakdown for materialized views.

How do you cut storage costs?

The storage worth checking first is the history Snowflake keeps for recovery.

Permanent tables keep changed and deleted data through a Time Travel period of up to 1 day on Standard Edition and up to 90 days on Enterprise Edition, followed by a Fail-safe period of 7 days that cannot be changed. Snowflake bills storage for all of it. And when a table is dropped or truncated, Snowflake keeps a full copy through those periods. A pipeline that truncates and reloads a large permanent table every day can end up paying to store several full copies of it.

The TABLE_STORAGE_METRICS view shows active, Time Travel and Fail-safe bytes for each table:

SELECT table_catalog,
       table_schema,
       table_name,
       ROUND(active_bytes / POWER(1024, 3), 1)      AS active_gb,
       ROUND(time_travel_bytes / POWER(1024, 3), 1) AS time_travel_gb,
       ROUND(failsafe_bytes / POWER(1024, 3), 1)    AS failsafe_gb
FROM snowflake.account_usage.table_storage_metrics
WHERE deleted = FALSE
ORDER BY failsafe_bytes + time_travel_bytes DESC
LIMIT 25

SELECT table_catalog,
       table_schema,
       table_name,
       ROUND(active_bytes / POWER(1024, 3), 1)      AS active_gb,
       ROUND(time_travel_bytes / POWER(1024, 3), 1) AS time_travel_gb,
       ROUND(failsafe_bytes / POWER(1024, 3), 1)    AS failsafe_gb
FROM snowflake.account_usage.table_storage_metrics
WHERE deleted = FALSE
ORDER BY failsafe_bytes + time_travel_bytes DESC
LIMIT 25

SELECT table_catalog,
       table_schema,
       table_name,
       ROUND(active_bytes / POWER(1024, 3), 1)      AS active_gb,
       ROUND(time_travel_bytes / POWER(1024, 3), 1) AS time_travel_gb,
       ROUND(failsafe_bytes / POWER(1024, 3), 1)    AS failsafe_gb
FROM snowflake.account_usage.table_storage_metrics
WHERE deleted = FALSE
ORDER BY failsafe_bytes + time_travel_bytes DESC
LIMIT 25

Tables near the top with more history than active data are the candidates. Three changes help:

  • Make work tables transient. Transient tables have no Fail-safe period, and Snowflake suggests them for short-lived data such as ETL work tables. Data in a transient table cannot be recovered once its Time Travel period ends, so use them only for data that can be rebuilt from its source.

  • Shorten Time Travel where nobody uses it. Long-lived fact tables may need 30 days or more. Staging tables rebuilt every night rarely need more than 1.

  • Clear stages and retire unused tables. Files left in internal stages after loading are billed as storage, and so are tables that the unused-pipelines review marks for deletion.

How do you cap Snowflake spend?

The fixes above lower the bill. A limit keeps a single mistake from raising it again, such as a warehouse left running over a weekend or a query stuck in a loop.

Resource monitors set a credit quota on one or more warehouses for a day, week, month or year. Each monitor can send up to five notifications and can suspend its warehouses when the quota is reached, either after running queries finish or immediately. Only account administrators can create them.

CREATE RESOURCE MONITOR transform_monthly
  WITH CREDIT_QUOTA = 500
  FREQUENCY = MONTHLY
  START_TIMESTAMP = IMMEDIATELY
  TRIGGERS ON 75 PERCENT DO NOTIFY
           ON 100 PERCENT DO SUSPEND
           ON 110 PERCENT DO SUSPEND_IMMEDIATE;

ALTER WAREHOUSE transform_wh SET

CREATE RESOURCE MONITOR transform_monthly
  WITH CREDIT_QUOTA = 500
  FREQUENCY = MONTHLY
  START_TIMESTAMP = IMMEDIATELY
  TRIGGERS ON 75 PERCENT DO NOTIFY
           ON 100 PERCENT DO SUSPEND
           ON 110 PERCENT DO SUSPEND_IMMEDIATE;

ALTER WAREHOUSE transform_wh SET

CREATE RESOURCE MONITOR transform_monthly
  WITH CREDIT_QUOTA = 500
  FREQUENCY = MONTHLY
  START_TIMESTAMP = IMMEDIATELY
  TRIGGERS ON 75 PERCENT DO NOTIFY
           ON 100 PERCENT DO SUSPEND
           ON 110 PERCENT DO SUSPEND_IMMEDIATE;

ALTER WAREHOUSE transform_wh SET

Set the quota from the warehouse’s own history, with room for a busy month. Match the action to the data the warehouse serves. A warehouse that feeds invoices or a finance close should notify people at its limit and keep running. A warehouse used for exploration can suspend.

Resource monitors cover warehouses only. For serverless features, Snowflake offers budgets, which set a monthly limit on a group of objects and the serverless features they use, and per-user quotas for limiting what individual users can spend.

Questions people ask

How much can these changes save?

The saving depends on where an account’s credits go today, and there is no reliable industry figure to borrow. Run the warehouse query before making changes and again a month later, and report the difference. That number is also the strongest case for the next round of work.

Does a lower auto-suspend setting always save money?

No. Snowflake bills at least 60 seconds every time a warehouse resumes, so a setting below 60 seconds saves nothing, and a warehouse that suspends between queries arriving a minute or two apart pays that minimum over and over. Set auto-suspend per warehouse, based on how often its queries arrive.

Should every warehouse be X-Small?

No. Large, complex queries scale roughly linearly with warehouse size, so they cost about the same on a bigger warehouse and finish sooner. Size each warehouse by testing its heaviest recurring queries, and keep separate warehouses for workloads with different needs.

Is compute or storage the bigger cost in Snowflake?

It depends on the account. Run the METERING_DAILY_HISTORY query for compute, and check the storage figures under Admin, Cost management in Snowsight, before choosing where to start.

Which Snowflake role can see cost data?

The ACCOUNT_USAGE views live in the shared SNOWFLAKE database, which only the ACCOUNTADMIN role can query by default. Snowflake provides database roles such as USAGE_VIEWER, so an administrator can grant cost visibility to a data team without granting full account control.

Where Dataring fits

We built Dataring to keep this work going after the first cleanup. It ranks every dataset by how much the business depends on it, then acts on that ranking. The datasets the business relies on get the resources to stay reliable, and the pipelines nobody depends on are retired within limits each company sets, under its supervision. The Snowflake credits that went to data nobody reads go to the data the business runs on.

Book a free call to see it on your data estate. For the wider process this guide fits into, read How to audit your data estate in seven steps.

Newsletter

Product news by email. We use your address for nothing else.

© 2026 ShareData Inc.Last updated October 29, 2026