Snowflake idle warehouse time: credits no query used
Snowflake meters every second a warehouse runs and attributes part of those credits to the queries that ran.
The difference is time the warehouse was awake with nothing to do.
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
Each warehouse's metered compute credits and the credits Snowflake attributes to its queries, from WAREHOUSE_METERING_HISTORY.
Why it costs money
- A warehouse bills while it waits for its auto-suspend timer, while it waits for the next query, and while it is left running.
- Idle time is often the largest single part of a Snowflake bill, and the meter shows it directly.
How the tool measures it
To investigate. The report shows what this costs now and where to look. It claims no saving, because the results cannot prove one.
Observed idle credits are metered compute credits minus attributed compute credits, at your credit price. This is a measured figure, not a model. Without the warehouse settings from query 3 the report cannot tell how much of it a shorter auto-suspend would remove, so it shows the cost and claims no saving.
When the report raises it. Query 2 is provided without query 3. With query 3, the same idle time is priced by the auto-suspend check instead.
In the sample report
The tool's sample does not raise this check, because its made-up account does not meet the condition above.
What to do
- 1Run query 3 (SHOW WAREHOUSES) as the same role as query 2 and add it, so the report can model auto-suspend and size.
- 2Look at the warehouses with the highest idle share first.
How to tell it worked. After any change, compare metered and attributed credits for the warehouse again over the same number of days.
Trade-offs. Some idle time is the price of a warm cache and fast first queries. The aim is less idle time, not none.
The read-only query 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;Other checks in the report
- Snowflake auto-suspend: what idle warehouse time costsPriced
- Snowflake warehouse one size smaller: when it savesPriced
- Snowflake transient tables: cutting Fail-safe storagePriced
- 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.