You opened your Supabase free-tier project and it was paused. You clicked restore, waited for it to spin back up, and now some tables look empty or the row counts are wrong. This is the scenario we pick up most often in support: not a bug, not data corruption, just a sequence of events that's easy to misread once you're in it.
Here's what's actually happening, what you can recover, and how to make sure it doesn't happen again.
What "paused" actually means on the free tier
A paused project is not a deleted project. When Supabase pauses a free-tier project, the database volume is frozen in place: no reads, no writes, no connections accepted until you restore it. Your data is still on disk.
Supabase pauses free-tier projects after a period of inactivity, measured by incoming API requests. The exact threshold can change as Supabase updates its policies. Check the current figure in the Supabase docs.
One detail that matters here: the free tier has zero days of backup retention. There's no snapshot Supabase is keeping of your data while the project sits paused. The backup system that Pro and Team plans use doesn't run on Free. How Supabase's native backup works explains what's covered at each plan level.
| Plan | Pauses on inactivity? | Backup retention | PITR available? |
|---|---|---|---|
| Free | Yes | 0 days | No |
| Pro | No | 7 days | Paid add-on |
| Team | No | 14 days | Paid add-on |
| Enterprise | No | 30 days | Usually included |
The inactivity threshold Supabase uses to trigger a free-tier pause has changed before and may change again. Don't memorize a specific number of days: check the Supabase dashboard or their documentation for the current policy.
Why some tables come back empty after unpausing
Most of the time, they don't. If your project was paused (not deleted), the data is intact and comes back with it. The problem is that "paused" and "deleted" look confusingly similar in the dashboard until you read the status closely.
Empty tables after unpausing usually trace to one of two things.
The project wasn't paused, it was deleted. Supabase has a second stage: if a free-tier project stays paused long enough without being restored, it transitions from paused to permanently deleted. Exact timing in Supabase docs. At that point, the "Restore project" path no longer exists, and what you're looking at might be a freshly-initialized project schema with no rows.
The dashboard loaded before the project finished resuming. When you click restore, the Postgres process takes anywhere from a few seconds to two or three minutes to be fully ready. Queries run in that window can return empty results or connection errors that look exactly like missing data. Wait until the dashboard shows a green "Active" status before running any queries.
A third, rarer case: the client connection is pointing at the wrong project or branch. Check the project reference in your app's connection string before assuming the data is gone.
What data is recoverable (and what isn't)
If the project is paused and the "Restore project" button is available: all Postgres data is recoverable. Unpause and you're back.
If the project has been deleted, that data is gone for free-tier projects. Supabase does not retain point-in-time copies of free-tier databases. There's no support escalation path that retrieves it.
Two gaps catch people off guard even when Postgres comes back clean.
Storage files are in a separate S3-compatible backend. The storage.objects metadata table lives in Postgres and is recoverable, but the actual file bytes are in a different layer that isn't part of the Postgres volume. If you restore the database after a deletion, you'll get table rows pointing to file paths that no longer exist. What Supabase's native backup doesn't cover covers this gap in detail.
Edge Functions are also separate. Source code, environment variable keys, and deploy history aren't in the database snapshot. If the project was deleted, those are gone independently of the Postgres data.
Step-by-step: unpausing and checking your data
- Log in to the Supabase dashboard.
- Find the project. If the status indicator shows "Paused," the data is still there.
- Click Restore project. The restore process takes between 30 seconds and 3 minutes.
- Wait for the status to read Active before doing anything else. Querying before the process completes is how you get the empty-tables false alarm.
- Open the SQL editor and run a quick size check across your tables:
SELECT
table_name,
pg_size_pretty(pg_total_relation_size(quote_ident(table_name))) AS table_size
FROM information_schema.tables
WHERE table_schema = 'public'
ORDER BY pg_total_relation_size(quote_ident(table_name)) DESC;
This lists every public-schema table with its on-disk size. A table with real data shows a meaningful size. A genuinely empty table shows 8–16 kB (the page header only). If everything in your schema reads 8 kB, you're likely looking at a deleted-then-recreated project, not a paused one.
- If the data looks correct, update your app's connection string and re-enable any workers or cron jobs that were pointing at the project.
The difference between paused, deleted, and expired
These three states look similar but have completely different outcomes.
| State | What it means | Data recoverable? | Path forward |
|---|---|---|---|
| Paused | Project frozen; data on disk | Yes | Click "Restore project" in dashboard |
| Deleted | Project and data permanently removed | No (free tier) | Restore from your own backup |
| Expired (Pro+) | Subscription lapsed, project on hold | Depends on grace period | Renew subscription, contact support |
The Supabase docs on project lifecycle and deletion describe the transitions between these states in detail. If you're in the "deleted" row and have no external backup, there's nothing left to do.
If your project has moved to "deleted" status and you're on a Pro or higher plan, contact Supabase support immediately. Pro plans have backup retention, and support may be able to initiate a restore before the retention window closes.
How to protect your free-tier project going forward
Three options, in order of effort.
Keep the project active. Supabase pauses on inactivity measured by API requests. Any request counts, including a health-check endpoint pinged on a cron schedule. One request a day is enough to prevent a pause. This doesn't protect you if the project is eventually deleted, but it eliminates the pause cycle.
Upgrade to Pro. A paused project is a free-tier problem. Pro projects don't pause on inactivity, and Pro adds 7 days of backup retention. If the project matters enough that losing the data would be a real problem, the $25/month answer is clearer than the scripting overhead.
Take a pg_dump before going idle. Before you know you won't be touching a project for a few weeks, run a manual export. This is the minimum floor of protection:
pg_dump --host=db.YOUR_PROJECT_REF.supabase.co --port=5432 --username=postgres --format=custom --file=supabase-backup-$(date +%F).dump postgres
Replace YOUR_PROJECT_REF with your project reference (visible in the Supabase dashboard URL and in Project Settings → General). The --format=custom flag produces a compressed binary that pg_restore can load selectively by table. Store it somewhere off your local machine.
How to back up Supabase Postgres (coming soon) covers this process in full, including scheduling and storage targets. For the manual process today, how to back up Supabase covers the connection string format and common options.
What to do next
If your project is currently paused, restore it now and run the SQL in the previous section before doing anything else. That check takes thirty seconds and tells you whether you're dealing with a paused project or a deleted one.
If you're deciding whether to stay on Free: the calculus is simple. If you'd be genuinely distressed to lose this project's data, the free tier is not the right home for it.
For the full walkthrough when things go further wrong, including navigating a project that's moved past "paused" into deletion territory, see Recover a paused Supabase project (coming soon).
If scripting and scheduling all this yourself sounds like a second job, SimpleBackups handles Supabase Postgres and Storage backups off-site, with alerts when a run fails. See how it works →
Keep learning
- How Supabase's native backup works, the mental model behind what a pause preserves and what it doesn't.
- What Supabase's native backup doesn't cover, because Storage and Edge Functions aren't in the snapshot even when the project is healthy.
- Recover a paused Supabase project (coming soon), the broader walkthrough for projects that have moved past "paused" into harder territory.
- How to back up Supabase Postgres (coming soon), the full
pg_dumpsetup so the next pause doesn't catch you without a copy. - How to back up Supabase, the manual reference for connection strings and backup options.
FAQ
How long before Supabase pauses a free-tier project?
Supabase pauses free-tier projects after a period of inactivity measured by incoming API requests. The exact threshold can change as Supabase updates its policies, so check the current figure in the Supabase documentation.
Can I recover data from a paused Supabase project?
Yes, if the project is paused and not yet deleted. Your data is intact on disk and comes back when you click "Restore project" in the Supabase dashboard. If the project has moved to "deleted" status, the data is permanently gone for free-tier projects.
Why are my tables empty after unpausing my Supabase project?
The most common cause is that the project was deleted rather than paused. Supabase permanently deletes free-tier projects that remain paused for an extended period without being restored. A second cause is loading the dashboard or running queries before the Postgres process has finished resuming: wait for the "Active" status before querying.
Does upgrading to Pro restore data from a paused project?
Upgrading to Pro stops future pausing and preserves data that is currently in paused state. It does not recover data that was already permanently deleted. If your project shows "Paused" right now and you upgrade before it is deleted, the data is safe.
Can I prevent my free-tier project from being paused?
Yes. Any API request to the project resets the inactivity timer. A daily cron-based health check ping is enough to keep the project awake. Upgrading to Pro removes the inactivity pause requirement entirely.
What happens to Supabase Storage when a project is paused?
Storage access is suspended when a project is paused. If the project is later deleted, Storage file bytes are deleted independently of the Postgres data. Supabase's native snapshot does not include Storage file bytes, so recovering Storage after a project deletion requires a separate external backup.
Is there a warning before Supabase pauses my project?
Supabase sends email notifications before pausing a free-tier project. Make sure the email address on your Supabase account is one you actively monitor, or set up inbox forwarding for project status notifications.
This article is part of The complete guide to Supabase backup, an honest, practical reference from the team that backs up Supabase every day.