Snowflake auto-suspend: what idle warehouse time costs
A Snowflake warehouse bills every second it is running, including the minutes it waits for its auto-suspend timer after the last query.
On warehouses with gaps between queries, a shorter setting is often the largest single saving.
Run read-only queries in your own console and paste the results. The report is worked out in your browser, with no access to your account.
What the check looks at
The gaps between each warehouse's queries over 30 days, its current AUTO_SUSPEND setting, and the credits Snowflake metered and attributed to queries.
Why it costs money
- A warehouse stays running after its last query until AUTO_SUSPEND seconds have passed, and it bills for all of that time. Snowflake's default is 600 seconds.
- Every time a warehouse resumes it bills at least 60 seconds, then by the second. A setting that is too short on a busy warehouse can bill more minimums than it saves.
- A setting of 0 or NULL means the warehouse never suspends on its own, so it bills around the clock unless someone stops it.
How the tool measures it
Priced. The report puts a monthly saving range on this check, from your own query results at your price.
Query 2 merges each warehouse's queries into busy stretches and measures every gap between them, at eight settings from 60 seconds to 3 hours. At a setting of T seconds a gap costs the smaller of the gap and T plus about 15 seconds, the time Snowflake takes to notice. The report prices your month at a 300-second setting for the low end and a 60-second setting for the high end. It never claims more than the idle credits Snowflake itself metered, and it scales the model down where it disagrees with the meter by more than a quarter.
When the report raises it. Queries 2 and 3 are both provided and a shorter setting would save at least a dollar a month on some warehouse.
In the sample report
Shorter auto-suspend
- TRANSFORM_WH: 600 seconds today.
- LOADER_WH: 300 seconds today.
- BI_WH: 3600 seconds today.
$1,828 to $6,602 a month, modeled.
From the tool's own sample: made-up results for one account over 30 days, priced at Enterprise list prices in US East (N. Virginia).
What to do
- 1Start with the warehouse that has the largest saving and the fewest resumes a day at the shorter setting.
- 2Change one warehouse: ALTER WAREHOUSE name SET AUTO_SUSPEND = 60 (or 120 or 300 for BI warehouses that serve people).
- 3Leave batch and loading warehouses lowest; they rarely benefit from a warm cache.
How to tell it worked. Compare that warehouse's credits in WAREHOUSE_METERING_HISTORY for the two weeks before and after, and watch query times on the first query after a resume.
Trade-offs. A suspended warehouse loses its local disk cache, so the first queries after a resume can read more from storage and run slower. A warehouse with a query every minute or two will resume often, and each resume bills at least 60 seconds.
The read-only queries behind it
The same SQL the tool gives you. Each reads usage views and changes nothing.
Query 2: warehouse activity, idle time and resumes
-- Finitizer Snowflake Cost Check, query 2 of 5: warehouse activity
-- sf-cost-check-v1 (2026-11-10). Read-only: it reads Account Usage and changes nothing.
-- Per warehouse: metered credits, the time queries kept it busy, and the idle time and
-- resumes it would have at each auto-suspend setting. Names and totals, no query text.
-- It reads 30 days of query history, so run it on a small warehouse. Allow a minute or two.
WITH w AS (
SELECT DATEADD(day, -30, DATE_TRUNC('day', CONVERT_TIMEZONE('UTC', CURRENT_TIMESTAMP()))) AS ws,
DATE_TRUNC('day', CONVERT_TIMEZONE('UTC', CURRENT_TIMESTAMP())) AS we
),
q AS (
SELECT h.warehouse_name, h.warehouse_size, h.start_time, h.end_time, h.execution_time,
h.execution_status, h.queued_overload_time,
h.bytes_spilled_to_local_storage, h.bytes_spilled_to_remote_storage
FROM snowflake.account_usage.query_history h, w
WHERE h.start_time >= w.ws AND h.start_time < w.we
AND h.warehouse_name IS NOT NULL
AND h.warehouse_size IS NOT NULL
AND h.end_time IS NOT NULL
),
o AS (
SELECT q.*,
MAX(end_time) OVER (PARTITION BY warehouse_name ORDER BY start_time, end_time
ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) AS prev_end
FROM q
),
g AS (
SELECT o.*,
GREATEST(0, DATEDIFF(millisecond, IFF(prev_end > start_time, prev_end, start_time), end_time)) / 1000 AS busy_s,
IFF(prev_end < start_time, DATEDIFF(millisecond, prev_end, start_time) / 1000, NULL) AS gap_s
FROM o
),
a AS (
SELECT warehouse_name,
MODE(warehouse_size) AS size_seen,
COUNT(*) AS queries,
COUNT_IF(UPPER(execution_status) <> 'SUCCESS') AS failed_queries,
SUM(busy_s) AS busy_seconds,
COUNT(gap_s) AS gaps,
SUM(gap_s) AS gap_seconds,
SUM(LEAST(gap_s, 75)) AS idle_60,
COUNT_IF(gap_s > 75) AS resumes_60,
SUM(LEAST(gap_s, 135)) AS idle_120,
COUNT_IF(gap_s > 135) AS resumes_120,
SUM(LEAST(gap_s, 315)) AS idle_300,
COUNT_IF(gap_s > 315) AS resumes_300,
SUM(LEAST(gap_s, 615)) AS idle_600,
COUNT_IF(gap_s > 615) AS resumes_600,
SUM(LEAST(gap_s, 915)) AS idle_900,
COUNT_IF(gap_s > 915) AS resumes_900,
SUM(LEAST(gap_s, 1815)) AS idle_1800,
COUNT_IF(gap_s > 1815) AS resumes_1800,
SUM(LEAST(gap_s, 3615)) AS idle_3600,
COUNT_IF(gap_s > 3615) AS resumes_3600,
SUM(LEAST(gap_s, 10815)) AS idle_10800,
COUNT_IF(gap_s > 10815) AS resumes_10800,
APPROX_PERCENTILE(execution_time, 0.95) / 1000 AS p95_execution_seconds,
SUM(bytes_spilled_to_local_storage) AS spill_local_bytes,
SUM(bytes_spilled_to_remote_storage) AS spill_remote_bytes,
SUM(queued_overload_time) / 1000 AS queued_overload_seconds,
COUNT_IF(queued_overload_time > 0) AS queued_queries
FROM g
GROUP BY warehouse_name
),
m AS (
SELECT warehouse_name,
SUM(credits_used_compute) AS credits_compute,
SUM(credits_used_cloud_services) AS credits_cloud_services,
SUM(credits_attributed_compute_queries) AS credits_attributed
FROM snowflake.account_usage.warehouse_metering_history, w
WHERE start_time >= w.ws AND start_time < w.we
GROUP BY warehouse_name
)
SELECT COALESCE(m.warehouse_name, a.warehouse_name) AS warehouse_name,
m.credits_compute, m.credits_cloud_services, m.credits_attributed,
a.size_seen, a.queries, a.failed_queries, a.busy_seconds, a.gaps, a.gap_seconds,
a.idle_60, a.resumes_60,
a.idle_120, a.resumes_120,
a.idle_300, a.resumes_300,
a.idle_600, a.resumes_600,
a.idle_900, a.resumes_900,
a.idle_1800, a.resumes_1800,
a.idle_3600, a.resumes_3600,
a.idle_10800, a.resumes_10800,
a.p95_execution_seconds, a.spill_local_bytes, a.spill_remote_bytes,
a.queued_overload_seconds, a.queued_queries,
TO_VARCHAR(w.ws, 'YYYY-MM-DD') AS window_start,
TO_VARCHAR(w.we, 'YYYY-MM-DD') AS window_end
FROM m
FULL OUTER JOIN a ON a.warehouse_name = m.warehouse_name
CROSS JOIN w
ORDER BY m.credits_compute DESC NULLS LAST;Query 3: warehouse settings (SHOW WAREHOUSES)
-- Finitizer Snowflake Cost Check, query 3 of 5: warehouse settings
-- sf-cost-check-v1 (2026-11-10). Read-only: it reads Account Usage and changes nothing.
-- Size, type, generation, auto-suspend and cluster counts for every warehouse your role can see.
-- Run it as the same role as query 2 (ACCOUNTADMIN sees every warehouse).
SHOW WAREHOUSES;Other checks in the report
- Snowflake warehouse one size smaller: when it savesPriced
- Snowflake transient tables: cutting Fail-safe storagePriced
- Snowflake idle warehouse time: credits no query usedTo investigate
- Snowflake cloud services credits: when they billTo investigate
- Snowflake background services: credits outside warehousesTo investigate
- Snowflake warehouse pressure: queuing and spillingTo investigate
- Snowflake failed queries: warehouse time with no resultTo investigate
- Snowflake poor pruning: queries that read most of a tableTo investigate
- Snowflake repeated queries: the same work every hourTo investigate
- Snowflake clone-retained storage: bytes kept for clonesTo investigate
- Snowflake stage storage: files left in internal stagesTo investigate
What a credit and a terabyte cost in each region and edition: Snowflake pricing in 2026. Finitizer does this for BigQuery today. Snowflake and Redshift support is on the way.