Wasted Snowflake spend is credits that buy no useful result. The common causes are idle warehouse time, oversized warehouses, extra clusters that never scale down, failed queries, serverless features on objects nobody reads, tables nobody reads, scheduled jobs that rerun without new data, and cloud services above the 10% allowance. Each one leaves a trace in Snowflake’s own views, so you can measure it before you fix it. Every fact and figure in this guide was checked against Snowflake’s documentation.
This article is part of our guide to Snowflake cost optimization.
What counts as wasted Snowflake spend?
Wasted Snowflake spend is any credit that pays for compute, storage or services without producing a result someone uses. Think of a warehouse running with no queries, or a table stored but never read. Unlike a sudden spike, it looks normal every day, so it survives cost reviews.
The causes below are common, but no Snowflake source ranks them, so they are not ordered by cost or frequency.
Does Snowflake flag wasted spend on its own?
Yes, partly. Snowflake’s Optimization insights check each account for nine cost patterns and refresh weekly. Each insight estimates the credits or terabytes you could save. They cover idle warehouses, fixed cluster counts, rarely used serverless features and unread tables, but not failed queries or oversized warehouses.
They sit under Admin, Cost management, Account Overview in Snowsight. According to the Account Overview access notes, the tile needs ACCOUNTADMIN, or a role with the APP_USAGE_VIEWER application role and the USAGE_VIEWER database role (or APP_USAGE_ADMIN with USAGE_ADMIN). USAGE_VIEWER alone is not enough. The nine insights are:
- Rarely used tables with automatic clustering: queried fewer than 100 times per week.
- Rarely used materialized views: queried fewer than 10 times per week.
- Rarely used search optimization paths: used fewer than 10 times per week.
- Large tables that are never queried: not queried in the last week.
- Tables over 100 GB that are written but never read.
- Short-lived permanent tables: over 100 GB and dropped within 24 hours of creation.
- Active warehouses idle more than 50% of the time they are active.
- Multi-cluster warehouses with the same minimum and maximum cluster count.
- Tables with 100 GB or more of cold storage: files no query has touched in a year.
The five query-count insights count queries “by this account”. Before you drop anything, check whether the object exists for disaster recovery or for data sharing. Snowflake gives this caution with its unused-object insights, and it applies to every such check here.
Where does each kind of waste show up in Snowflake?
Each cause appears in a specific Account Usage view or command. Idle time sits in WAREHOUSE_METERING_HISTORY, failed work in QUERY_HISTORY, unused objects in ACCESS_HISTORY and TABLE_STORAGE_METRICS, and billed cloud services in METERING_DAILY_HISTORY. The table maps each cause to what to check and where the fix is covered. It is not a ranking.
| Cause | Where it shows up | What to check | Fix |
|---|---|---|---|
| Idle warehouse time | WAREHOUSE_METERING_HISTORY | Compute minus credits attributed to queries | Auto-suspend settings |
| Warehouses that never suspend | SHOW WAREHOUSES | auto_suspend is 0 or NULL |
Auto-suspend settings, as above |
| Oversized warehouses | QUERY_HISTORY | Short queries, no spilling, no queuing | Warehouse sizes |
| Clusters pinned at a fixed count | SHOW WAREHOUSES | Minimum equals maximum, above 1 | Multi-cluster warehouses |
| Failed or canceled queries | QUERY_HISTORY | execution_status, error_message |
Fix the failing job, below |
| Serverless features nobody uses | Clustering, materialized view and search optimization history views; ACCESS_HISTORY | Credits against read counts | Auto-clustering costs |
| Tables nobody reads | TABLE_STORAGE_METRICS, ACCESS_HISTORY | Large tables with no recorded reads | Review before dropping, below |
| Reruns with no new data | TASK_HISTORY | Scheduled tasks with no WHEN condition | Streams and WHEN conditions, below |
| Cloud services above 10% | METERING_DAILY_HISTORY | Used plus adjustment above zero | Cloud services credits |
Snowflake bills cloud services only above 10% of the day’s warehouse credits, daily in UTC. In METERING_DAILY_HISTORY, add CREDITS_USED_CLOUD_SERVICES to the negative CREDITS_ADJUSTMENT_CLOUD_SERVICES. Summed for each USAGE_DATE, any day above zero is a billed day.
How do you find idle warehouse time?
Subtract the credits attributed to queries from each warehouse’s compute credits. WAREHOUSE_METERING_HISTORY has both columns, and Snowflake documents this subtraction as the cost of idle time. A high idle share points at a long auto-suspend window or at small, frequent queries that keep waking the warehouse.
The Account Usage reference lists each view’s role and latency.
Warehouses bill per second with a 60-second minimum each time they start. CREATE WAREHOUSE sets AUTO_SUSPEND to 600 seconds by default, and a value of 0 or NULL means the warehouse never suspends.
-- Idle credits and idle share per warehouse, last 30 days. Latency up to 3 hours.
-- Role: ACCOUNTADMIN, or a role with the SNOWFLAKE.USAGE_VIEWER database role.
SELECT warehouse_name,
SUM(credits_used_compute) AS compute_credits,
SUM(credits_used_compute) - SUM(credits_attributed_compute_queries) AS idle_credits,
ROUND(100 * (SUM(credits_used_compute) - SUM(credits_attributed_compute_queries))
/ NULLIF(SUM(credits_used_compute), 0), 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 idle_credits DESC;
The attributed column is NULL for Adaptive Warehouses, so they show no idle figure here.
What does one idle wake-up cost?
An illustrative case: new standard warehouses default to Gen2, and a Gen2 Medium on AWS uses 5.4 credits per hour (Service Consumption Table, Table 1(b), effective 12 November 2026). A check runs a 2-second query hourly, waking the suspended warehouse each time.
- Default AUTO_SUSPEND of 600 seconds: each wake-up bills about 602 seconds, so 99.7% of it is idle. That is 0.903 credits, or $2.71 at $3.00 per credit (Enterprise, on demand, AWS US East, Northern Virginia, Table 2(a)). Over 30 days, 720 wake-ups use 650.16 credits, or $1,950.48.
- AUTO_SUSPEND of 60 seconds: each wake-up bills about 62 seconds. The same 720 wake-ups use 66.96 credits, or $200.88 at the same $3.00 rate (Enterprise, on demand, AWS US East, Northern Virginia).
The figures ignore the 30-second suspend check, so real numbers can be slightly higher. However, lower is not always better. With queries every 2 or 3 minutes, a 1-minute setting cycles the warehouse, and each resume bills 60 seconds (warehouse considerations).
How do you spot oversized warehouses and pinned clusters?
Look for large warehouses whose queries finish quickly without spilling or queuing. Snowflake says larger is not necessarily faster for small, basic queries, so they pay a higher hourly rate for no gain. For clusters, look for multi-cluster warehouses whose minimum and maximum counts match, which starts every cluster whenever the warehouse runs.
-- Query profile by warehouse and size, last 14 days. Latency up to 45 minutes.
-- Role: ACCOUNTADMIN, or a role with the SNOWFLAKE.GOVERNANCE_VIEWER database role.
SELECT warehouse_name,
warehouse_size,
COUNT(*) AS queries,
MEDIAN(execution_time) / 1000 AS median_exec_seconds,
COUNT_IF(bytes_spilled_to_local_storage + bytes_spilled_to_remote_storage > 0) AS spilling_queries,
COUNT_IF(queued_overload_time > 0) AS queued_queries
FROM snowflake.account_usage.query_history
WHERE start_time >= DATEADD(day, -14, CURRENT_TIMESTAMP())
AND warehouse_size IS NOT NULL
GROUP BY warehouse_name, warehouse_size
ORDER BY median_exec_seconds;
Treat the result as a shortlist. Snowflake advises running the same queries on several sizes, then you can keep the smallest that meets your target.
One command finds never-suspend warehouses and pinned clusters. It reads SHOW WAREHOUSES output through the pipe operator:
-- Warehouses that never auto-suspend, or that run every cluster whenever they run. Current state, no latency.
-- Lists only warehouses your role has privileges on.
SHOW WAREHOUSES
->> SELECT "name", "size", "auto_suspend", "min_cluster_count", "max_cluster_count"
FROM $1
WHERE "auto_suspend" IS NULL OR "auto_suspend" = 0
OR ("min_cluster_count" = "max_cluster_count" AND "max_cluster_count" > 1);
Equal minimum and maximum counts is Maximized mode, which suits steady, high concurrency. Multi-cluster warehouses need Enterprise Edition or higher.
Do failed queries waste Snowflake credits?
They can. A running warehouse bills per second. So a query that fails after ten minutes kept the warehouse busy for ten paid minutes. QUERY_HISTORY records each statement’s status and execution time, so you can measure warehouse time spent on work that ended in an error.
Canceled queries are identified by the error_message text “SQL execution canceled”, not by execution_status. Retries also cost time: query_retry_time and query_retry_cause show retries from actionable errors, such as running out of memory.
-- Failed and canceled statements by warehouse, last 30 days. Latency up to 45 minutes.
-- Role: ACCOUNTADMIN, or a role with the SNOWFLAKE.GOVERNANCE_VIEWER database role.
SELECT warehouse_name,
warehouse_size,
COUNT(*) AS failed_statements,
ROUND(SUM(execution_time) / 3600000, 2) AS execution_hours
FROM snowflake.account_usage.query_history
WHERE start_time >= DATEADD(day, -30, CURRENT_TIMESTAMP())
AND warehouse_name IS NOT NULL
AND (UPPER(execution_status) <> 'SUCCESS'
OR error_message = 'SQL execution canceled')
GROUP BY warehouse_name, warehouse_size
ORDER BY execution_hours DESC;
The result is hours, not credits, because concurrent queries share a warehouse. Group the worst warehouse by user_name and error_code to find the job behind it.
Which serverless features and tables cost money while nobody uses them?
Automatic clustering, materialized views and search optimization keep billing serverless credits as their tables change, whether or not anyone queries them. Large tables keep billing storage too. To find them, compare what each object costs with how often ACCESS_HISTORY shows it being read.
ACCESS_HISTORY needs Enterprise Edition or higher, as do materialized views and search optimization. This query sets clustering credits against read counts:
-- Auto-clustering credits and read queries per table, last 7 days. Both views lag up to 3 hours.
-- Role: ACCOUNTADMIN, or a role with both SNOWFLAKE.USAGE_VIEWER and SNOWFLAKE.GOVERNANCE_VIEWER.
WITH clustering AS (
SELECT table_id, database_name, schema_name, table_name, SUM(credits_used) AS credits
FROM snowflake.account_usage.automatic_clustering_history
WHERE start_time >= DATEADD(day, -7, CURRENT_TIMESTAMP())
GROUP BY table_id, database_name, schema_name, table_name
),
reads AS (
SELECT TRY_TO_NUMBER(f.value:"objectId"::STRING) AS table_id, COUNT(DISTINCT query_id) AS read_queries
FROM snowflake.account_usage.access_history,
LATERAL FLATTEN(base_objects_accessed) f
WHERE query_start_time >= DATEADD(day, -7, CURRENT_TIMESTAMP())
GROUP BY TRY_TO_NUMBER(f.value:"objectId"::STRING)
)
SELECT c.database_name, c.schema_name, c.table_name, c.credits,
COALESCE(r.read_queries, 0) AS read_queries
FROM clustering c
LEFT JOIN reads r ON r.table_id = c.table_id
ORDER BY c.credits DESC;
The window is one week, so read_queries is on the same basis as Snowflake’s threshold of 100 queries a week. It also counts DML that reads the table, such as MERGE, so treat it as a rough guide. You can pause clustering with ALTER TABLE ... SUSPEND RECLUSTER, which keeps the clustering key. However, tables clustered since 1 September 2026 use Optima Clustering, and resuming it adds a catch-up cost for data loaded while it was paused. To stop paying for good, drop the clustering key instead.
For storage, the same reads list works against TABLE_STORAGE_METRICS:
-- Live tables over 100 GB with no reads recorded in ACCESS_HISTORY in 30 days. Latency up to 3 hours.
-- Role: ACCOUNTADMIN, or a role with both SNOWFLAKE.USAGE_VIEWER and SNOWFLAKE.GOVERNANCE_VIEWER.
-- A row here is a candidate to review, not proof that nobody uses the table.
WITH reads AS (
SELECT DISTINCT TRY_TO_NUMBER(f.value:"objectId"::STRING) AS table_id
FROM snowflake.account_usage.access_history,
LATERAL FLATTEN(base_objects_accessed) f
WHERE query_start_time >= DATEADD(day, -30, CURRENT_TIMESTAMP())
)
SELECT t.table_catalog, t.table_schema, t.table_name,
ROUND(t.active_bytes / POWER(1024, 3), 1) AS active_gb,
ROUND((t.time_travel_bytes + t.failsafe_bytes) / POWER(1024, 3), 1) AS history_gb
FROM snowflake.account_usage.table_storage_metrics t
LEFT JOIN reads r ON r.table_id = t.id
WHERE t.deleted = FALSE
AND t.active_bytes > 100 * POWER(1024, 3)
AND r.table_id IS NULL
ORDER BY t.active_bytes DESC;
A table on this list is a candidate to review, not proof of disuse. ACCESS_HISTORY does not record every query, and reads by accounts you share the table with never appear in your account.
Dropping a permanent table does not end its cost at once. Permanent tables keep 7 days of Fail-safe after Time Travel, while transient and temporary tables have none. So data you rebuild often, or drop within a day, can go in a transient table, as long as you can reproduce it from outside Snowflake.
How do you stop scheduled jobs that rerun with no new data?
Give each scheduled task a condition. A task created with WHEN SYSTEM$STREAM_HAS_DATA('stream') skips its run when the stream has no change data. Checking the condition uses no warehouse, only a nominal cloud services charge. Tasks with no WHEN clause run on every schedule, whether their source changed or not.
One caveat from the CREATE TASK reference: the function is not guaranteed to return FALSE when there is no change data. TASK_HISTORY records each run and its WHEN text:
-- Scheduled runs of tasks with no WHEN condition that succeeded, last 30 days. Latency up to 45 minutes.
-- Role: ACCOUNTADMIN, or a role with the SNOWFLAKE.USAGE_VIEWER database role.
SELECT database_name, schema_name, name AS task_name,
COUNT(*) AS runs,
MIN(scheduled_time) AS first_run,
MAX(scheduled_time) AS last_run
FROM snowflake.account_usage.task_history
WHERE scheduled_time >= DATEADD(day, -30, CURRENT_TIMESTAMP())
AND state = 'SUCCEEDED'
AND scheduled_from = 'SCHEDULE'
AND COALESCE(condition_text, '') = ''
GROUP BY database_name, schema_name, name
ORDER BY runs DESC;
Child tasks in a task graph also appear, but they run only when their root runs, so review the root. If a task’s source changes less often than it runs, add a stream and a WHEN condition. For dynamic tables, DYNAMIC_TABLE_REFRESH_HISTORY marks REFRESH_ACTION as NO_DATA when base tables have no new data.
How Seemore helps with wasted Snowflake spend
Seemore’s Intelligent Auto-Clustering reviews tables that use automatic clustering to judge whether it still pays off, recommends keeping, optimizing or disabling it with an estimated cost impact, and suggests clustering keys for tables that are not clustered, with the SQL to apply each change. Cost Anomaly Detection compares each day’s spend for the accounts and warehouses its rules cover against the previous 14 days and explains the likely root cause of each spike or drop. Real Time Monitoring shows what is running and queued on every warehouse across your connected accounts, and can list the queries behind the load, and the Seemore platform attributes cost by user, domain and query tag, so you can see which tool or pipeline ran each query. You can also ask Seemore Assistant about your environment in plain language instead of writing the SQL above.
Frequently asked questions
What is wasted Snowflake spend?
It is credits spent on compute, storage or services that produce no result anyone uses. Common examples are idle warehouse time, clustering on tables nobody queries, large unread tables, failed queries, and jobs that rerun with no new data. Each can be measured in Snowflake’s Account Usage views.
Does Snowflake show wasted spend in Snowsight?
Partly. The Optimization insights tile under Admin, Cost management, Account Overview checks for nine patterns weekly, such as warehouses idle more than half the time and tables over 100 GB that are written but never read. It needs ACCOUNTADMIN, or the APP_USAGE_VIEWER application role together with the USAGE_VIEWER database role.
How do I calculate idle cost per warehouse in Snowflake?
In SNOWFLAKE.ACCOUNT_USAGE.WAREHOUSE_METERING_HISTORY, subtract SUM(CREDITS_ATTRIBUTED_COMPUTE_QUERIES) from SUM(CREDITS_USED_COMPUTE) for each warehouse. Snowflake documents this as the cost of idle time. The view lags up to 3 hours, and the attributed column is NULL for Adaptive Warehouses.
How do I find canceled queries in Snowflake query history?
Filter ACCOUNT_USAGE.QUERY_HISTORY on error_message = ‘SQL execution canceled’. Snowflake identifies canceled queries by that text, not by the execution_status column. Add execution_time and warehouse_name to see how much warehouse time they used, and group by user_name to find the source.
How do I find Snowflake tables that nobody queries?
On Enterprise Edition or higher, list table IDs in ACCESS_HISTORY’s base_objects_accessed, then find large tables in TABLE_STORAGE_METRICS with no reads recorded there. ACCESS_HISTORY does not log every query, so treat the list as candidates. Also check for disaster recovery or data sharing use.
How often should I check for wasted Snowflake spend?
Snowflake refreshes its Optimization insights weekly, so a weekly review lines up with it. The views behind this guide’s queries lag 45 minutes to 3 hours. Check auto-suspend whenever a warehouse is created, because CREATE WAREHOUSE defaults to 600 seconds.