Snowflake Time Travel cost is plain storage cost. Snowflake bills the history it keeps for Time Travel and Fail-safe at the same rate per TB as your live data. A permanent table keeps changed data for its retention period, 1 day by default and up to 90 days on Enterprise Edition or higher. Then it keeps it for 7 more days of Fail-safe, which you cannot turn off. Every fact and figure in this guide was checked against Snowflake’s documentation.
This article is part of our guide to Snowflake cost optimization. For the wider picture, see our guide to Snowflake storage costs.
How does Snowflake bill Time Travel and Fail-safe?
Snowflake bills Time Travel and Fail-safe bytes as storage, at your normal rate per TB per month. The fee runs for each day from the moment data changes until it leaves Fail-safe. Snowflake keeps the micro-partitions that held changed rows, not the whole table, unless the table is dropped or truncated.
The storage cost page counts table data, Time Travel and Fail-safe in one line, on compressed size, and the Time Travel and Fail-safe cost page sets the daily timing. Table 3(a) of the Service Consumption Table sets $23.00 per TB per month on demand in AWS US East (N. Virginia), in every edition. Our guide to on-demand vs capacity pricing covers contract rates.
How long does Snowflake keep history for each table type?
A permanent table keeps history for its Time Travel retention, then 7 days of Fail-safe. Standard Edition allows 0 or 1 day of Time Travel, so 8 days at most. Enterprise and higher allow up to 90 days, so up to 97. Transient and temporary tables allow 0 or 1 day and have no Fail-safe.
| Table type | Edition | Time Travel days | Fail-safe days | Most days billed |
|---|---|---|---|---|
| Permanent | Standard | 0 or 1 | 7 | 8 |
| Permanent | Enterprise or higher | 0 to 90 | 7 | 97 |
| Transient | Any | 0 or 1 | 0 | 1 |
| Temporary | Any | 0 or 1, ends with the session | 0 | 1 |
Retention is set by the DATA_RETENTION_TIME_IN_DAYS parameter, default 1, on the account, database, schema or table. An account floor, MIN_DATA_RETENTION_TIME_IN_DAYS, wins when it is higher, for permanent tables only. You can see each table’s value in the retention_time column of SHOW TABLES.
Streams can stretch these limits. If a table’s retention is under 14 days and a stream on it has not been consumed, Snowflake extends the table’s retention to the stream’s offset, up to 14 days by default, in every edition. MAX_DATA_EXTENSION_TIME_IN_DAYS sets that cap.
Can you turn off Fail-safe in Snowflake?
No, not on a permanent table. Snowflake’s Fail-safe page calls it a non-configurable 7-day period that starts when Time Travel ends. For standard Snowflake tables, the way to avoid it is a transient or temporary table, which has no Fail-safe period. Setting Time Travel retention to 0 does not skip Fail-safe.
With 0 retention, Snowflake moves a permanent table’s changed data straight into Fail-safe, so it still bills 7 days of history.
Does Snowflake charge to recover data from Fail-safe?
Yes. Fail-safe bytes are billed as storage while they sit there, and a recovery is billed again as serverless compute. The Fail-safe page says recovery uses Snowflake-managed compute at standard serverless rates, under the service type FAILSAFE_RECOVERY. You request it through a Support case.
Table 5 of the Service Consumption Table gives Failsafe Recovery a compute multiplier of 0.9 and a cloud services multiplier of 1. No compute-hour estimate is published, so there is no fixed price. Recovery is best effort and can take several hours to several days. See our guide to Snowflake serverless costs.
Why do high-churn tables pile up Time Travel and Fail-safe bytes?
An update or delete re-creates every affected micro-partition, and the old ones start their Time Travel and Fail-safe clock. So the rewritten micro-partitions set the bill, not the changed rows alone. A table that changes many times a day can carry far more history than live data.
Snowflake’s data storage considerations page gives an extreme example. In a 200 GB table where every row is updated 20 times a day, 4 TB sits in Time Travel and 28 TB in Fail-safe. That is 32.2 TB billed for 200 GB of live data.
Three patterns create most of this history:
- Updates and deletes. Dimension tables and merge targets rewrite micro-partitions on each change. A high ratio of
FAILSAFE_BYTEStoACTIVE_BYTESmarks a high-churn table. - Full rewrites.
CREATE OR REPLACE TABLEdrops the old table, and each old version keeps its own history as a full copy. - Appends. Even INSERT, COPY and Snowpipe loads create history, because Snowflake defragments small micro-partitions.
What does a worked example of Snowflake Time Travel cost look like?
In this illustration, a 2 TB permanent table rebuilt every night costs $414.00 a month to store. That is on demand in AWS US East, at $23.00 per TB, in any edition. Only $46.00 of it is live data. The other 16 TB is history: 2 TB in Time Travel and 14 TB in Fail-safe.
The table is made up. Each nightly CREATE OR REPLACE leaves a full 2 TB copy, so each state holds about one day’s rewrite times the days it lasts. Figures are approximate steady state. The 7-day row needs Enterprise or higher.
| Setup (illustrative) | Live | Time Travel | Fail-safe | Billed | Per month |
|---|---|---|---|---|---|
| Permanent, 1-day retention | 2 TB | 2 TB | 14 TB | 18 TB | $414.00 |
| Permanent, 7-day retention (Enterprise) | 2 TB | 14 TB | 14 TB | 30 TB | $690.00 |
| Transient, 1-day retention | 2 TB | 2 TB | 0 | 4 TB | $92.00 |
| Transient, 0-day retention | 2 TB | 0 | 0 | 2 TB | $46.00 |
In this illustration (any edition, on demand, AWS US East), Fail-safe is $322.00 of the permanent table’s $414.00, and no retention setting removes it. Each extra day of Time Travel adds 2 TB, or $46.00 a month. So moving from 1 to 7 days, on Enterprise or higher, adds $276.00 a month.
On capacity, Tier 1 storage in AWS US East costs the same $23.00. Lower tiers apply to an Order Form designated a “Qualifying Order”; other order forms pay Tier 1 rates unless their terms say otherwise, so check your order form.
How do you estimate the cost of changing Time Travel retention?
Multiply the bytes a table rewrites per day by the retention days you add or remove, then by your storage rate. That is the arithmetic of Snowflake’s 200 GB example. On permanent tables, Fail-safe stays at 7 days of churn whatever retention you pick, so only Time Travel moves.
Once retention has been stable for at least 7 days, Fail-safe holds about 7 days of changes on a permanent table, so FAILSAFE_BYTES divided by 7 approximates daily churn. This is our derivation, not a Snowflake formula. It holds only when churn is steady, the table is older than its retention plus 7 days, and retention has not been lowered in the last 7 days. For tables rebuilt with CREATE OR REPLACE, whose old versions sit on separate rows, use table size times rebuilds per day.
How do you measure Time Travel and Fail-safe bytes in your account?
Query the ACCOUNT_USAGE TABLE_STORAGE_METRICS view. It splits each table’s billed bytes into active, Time Travel, Fail-safe and retained-for-clone bytes, including dropped tables that still cost money. Data can be up to 90 minutes behind. Run it as ACCOUNTADMIN or with the USAGE_VIEWER database role.
RETAINED_FOR_CLONE_BYTES counts deleted bytes that a clone or backup still references. Dropped tables in Fail-safe may show NULL names, so list rows by ID. Hybrid tables are not in this view.
-- Table versions holding the most Time Travel and Fail-safe bytes, including dropped versions, in TB (latency up to 90 minutes)
SELECT id,
table_catalog,
table_schema,
table_name,
is_transient,
deleted,
table_dropped,
active_bytes / POWER(1024, 4) AS active_tb,
time_travel_bytes / POWER(1024, 4) AS time_travel_tb,
failsafe_bytes / POWER(1024, 4) AS failsafe_tb,
retained_for_clone_bytes / POWER(1024, 4) AS clone_retained_tb,
failsafe_bytes / NULLIF(active_bytes, 0) AS failsafe_to_active
FROM snowflake.account_usage.table_storage_metrics
WHERE COALESCE(time_travel_bytes, 0) + COALESCE(failsafe_bytes, 0)
+ COALESCE(retained_for_clone_bytes, 0)
+ IFF(COALESCE(deleted, TRUE), COALESCE(active_bytes, 0), 0) > 0
ORDER BY COALESCE(time_travel_bytes, 0) + COALESCE(failsafe_bytes, 0)
+ COALESCE(retained_for_clone_bytes, 0)
+ IFF(COALESCE(deleted, TRUE), COALESCE(active_bytes, 0), 0) DESC
LIMIT 25;
For a dropped version, ACTIVE_BYTES shows the bytes that would be active if you restored it, so the query ranks them as history. The next query applies the churn estimate to current permanent tables, with the same role.
-- Estimated daily churn per current permanent table, in TB (latency up to 90 minutes)
SELECT table_catalog,
table_schema,
table_name,
time_travel_bytes / POWER(1024, 4) AS time_travel_tb,
failsafe_bytes / POWER(1024, 4) AS failsafe_tb,
failsafe_bytes / 7 / POWER(1024, 4) AS est_daily_churn_tb
FROM snowflake.account_usage.table_storage_metrics
WHERE deleted = FALSE
AND is_transient = 'NO'
ORDER BY failsafe_bytes DESC
LIMIT 25;
Compare each table’s retention_time from SHOW TABLES before you multiply. Fail-safe recoveries appear in the METERING_DAILY_HISTORY view as FAILSAFE_RECOVERY, up to 3 hours late. Our guide on how to check Snowflake costs covers account-level storage views.
How do you cut Time Travel and Fail-safe costs, and what do you give up?
Lower retention on large, high-churn permanent tables, and move rebuildable staging data to transient tables. Both cut history, and both cut what you can recover. Keep fact tables and anything hard to reload as permanent, because among standard tables only those get Fail-safe.
Steps that reduce history
- Lower retention where nobody uses history with
ALTER TABLE ... SET DATA_RETENTION_TIME_IN_DAYS = 1. A higher account floor still wins. - Expect the saving later. Data outside the new period moves into Fail-safe for 7 more days. Already-dropped tables keep their old retention.
- Use transient tables for rebuildable data. dbt makes table models transient by default, but not dynamic tables. See our guide to the Snowflake cost of dbt models.
- Migrate with care. Transient and temporary tables cannot be converted to another type, and Snowflake’s documented route from permanent to transient is a migration: CREATE TABLE AS SELECT, copy grants, drop the original and rename. The dropped original stays for its retention plus 7 days.
- For very large, high-churn tables, Snowflake suggests a transient table with 0 retention plus a daily permanent backup copy: 2 TB instead of 32.2 TB in its example.
- Consume or drop idle streams, or lower
MAX_DATA_EXTENSION_TIME_IN_DAYS. A lower cap means an unconsumed stream goes stale sooner.
What you give up
Every cut removes a recovery option. With 0 retention, a dropped object cannot be restored, and Snowflake recommends at least 1 day. Transient table history cannot be recovered by Snowflake once Time Travel ends. Since BCR-2360, Snowflake Backups no longer support transient tables either. Fail-safe also does not support tables that hold data loaded by the classic Snowpipe Streaming architecture, so plan another backup for those.
How Seemore helps with Time Travel and Fail-safe costs
The queries above are a manual routine that depends on someone running and reading them. Seemore’s 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. 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
How is Snowflake Time Travel cost calculated?
Snowflake bills Time Travel bytes as storage, at your normal rate per TB per month for your region and contract. The fee runs for each day from the time data changes. A dropped or truncated table is kept as a full copy.
Can you disable Fail-safe in Snowflake?
Not for permanent tables. Fail-safe is a fixed 7-day period after Time Travel ends, and retention 0 sends changed data straight into it. Among standard tables, only transient and temporary tables avoid it, and their history cannot be recovered once Time Travel ends.
Does Snowflake charge to recover data from Fail-safe?
Yes. A Fail-safe recovery runs on Snowflake-managed serverless compute at standard serverless rates, under the service type FAILSAFE_RECOVERY. The price table gives it a 0.9 compute multiplier. You request it through Snowflake Support, and it can take from several hours to several days.
What is the maximum Snowflake Time Travel retention period?
90 days, on Enterprise Edition or higher, for permanent databases, schemas and tables. Standard Edition allows 0 or 1 day, and transient and temporary tables allow 0 or 1 day in every edition. Unconsumed streams can extend retention up to 14 days by default.
How can I estimate the Snowflake Time Travel cost of a longer retention period?
Multiply the bytes the table rewrites each day by the extra days, then by your storage rate. As a rough estimate of our own, not a Snowflake formula, FAILSAFE_BYTES divided by 7 in TABLE_STORAGE_METRICS approximates daily churn for a permanent table with steady churn.
Why are Snowflake Fail-safe bytes larger than active bytes?
Because Fail-safe holds 7 days of changes, and each update rewrites whole micro-partitions. A table that is updated every day can hold several times its live size in Fail-safe. Snowflake treats a large ratio of FAILSAFE_BYTES to ACTIVE_BYTES as the sign of a high-churn table.