Skip to content
Finitizer
To investigate

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 this check on your own account

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

  1. 1Run query 3 (SHOW WAREHOUSES) as the same role as query 2 and add it, so the report can model auto-suspend and size.
  2. 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

All checks

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.