What's in this guide
If someone drops a table at 14:02, Neon can put the branch back the way it was at 14:01, usually in seconds and without a dump file. Instant restore, Time Travel and backup schedules all work that way, and a deleted project can still be recovered for seven days.
More than 150 teams back up Neon databases with us, and their settings say something we did not expect. Only about one in eight of the scheduled Neon backups we run keeps more than 35 days of history. The rest keep 35 days or less, a window Neon's own backup schedules already reach. So retention is rarely why people add a second copy. Location is: they want one copy that is not in the same Neon project, under the same account, as the data it protects.
That line, between recovery inside Neon and a backup outside it, runs through every article below. If you run production on Neon, or a customer has just asked where your off-site copy is, start with the two in this section. The reference is the Neon backups documentation. We link the specific page behind every figure in this guide, and say so where the docs are silent.
How Neon's native backup works: instant restore, snapshots and the history window
What Neon keeps, for how long on each plan, what a restore actually rewrites, and how snapshots and backup schedules fit next to instant restore.
What Neon's native backup doesn't cover
Six gaps, from the 35-day ceiling on every backup schedule (monthly included) to the seven-day deletion window, and which of them matter for your project. The honest version, including when native is enough.
How to back up Neon
The only portable copy of a Neon database is a pg_dump. Take one with the unpooled connection string, then get it on a schedule and off Neon's infrastructure.
How to back up a Neon database with pg_dump
The connection string, the exact pg_dump and pg_restore commands, and how to send the dump to storage you control.
Automate Neon backups to your own storage
A step-by-step setup with a dedicated backup user, a schedule, an off-site destination and a test restore, without writing a script.
How to restore
Neon gives you three restore paths and they are not interchangeable. Which one you reach for depends on how far back you need to go, and whether the project still exists.
How to restore a Neon database: instant restore, snapshot or pg_restore
When to use each path, the exact commands, what a restore overwrites, and how to recover a single table without rewinding the whole branch.
Deleted a Neon project or branch? What you can still recover
Coming soonThe seven-day recovery window, the commands that undelete a project, and what is gone for good once it closes.
Compare your options
Most Neon teams start with instant restore and add a pg_dump script when someone asks for an off-site copy. This is the side-by-side for when that script starts needing maintenance.
Neon backup options compared: native, scripts and managed tools
Coming soonInstant restore, scheduled snapshots, a pg_dump and GitHub Actions pipeline, and managed backup services, with what each is good at and where each stops.
Advanced
Back up Neon before migrating to another Postgres host
Coming soonThe dump, the restore into the new host, the checks that prove nothing was lost, and the rollback plan if the cutover goes wrong.
Off-site Neon backups for GDPR and SOC 2
Coming soonWhat auditors ask about database backups, why in-account recovery rarely satisfies them, and how to produce the evidence they want.
Neon backup FAQ
Each answer stands on its own and quotes Neon's limits as they were on 3 November 2026. If you came for one number, it is probably here.
Does Neon back up my database?
Neon keeps a history of every change for a window that depends on your plan: 6 hours on Free, up to 7 days on Launch and up to 30 days on Scale. Inside that window you can restore a root branch to any second, which Neon calls instant restore. Paid plans can also schedule snapshots kept for up to 35 days. All of it lives inside your Neon project, so it is recovery, not an off-site backup.
Is Neon instant restore a backup?
It is point-in-time recovery, and a very good one, but it is not an independent copy. The history it restores from sits in the same Neon project as the data. If the project is deleted, the account is locked or the history window has rolled past the moment you need, instant restore cannot help. A backup is a copy stored somewhere the original can't take down with it.
How long does Neon keep my history?
The history window defaults to 6 hours on Free, capped at 1 GB of changes, and to 1 day on paid plans. You can raise it to 7 days on Launch and 30 days on Scale. Longer windows cost more, because Neon bills retained history at $0.20 per GB-month. Anything older than the window is gone from instant restore.
Can I download a Neon snapshot?
Neon's documentation describes no way to download or export a snapshot. Snapshots are restored inside Neon. If you need a file you can keep, move or restore into another Postgres provider, run pg_dump against the unpooled connection string and store the output somewhere you control.
What happens to my backups if I delete a Neon project?
A deleted Neon project, with its branches and snapshots, can be recovered for 7 days through the CLI or API. After that the deletion is permanent and nothing in the project survives, including its history and snapshots. Integrations such as Vercel, GitHub and the Data API have to be reconnected even after a successful recovery.
How do I back up a Neon database with pg_dump?
Copy the connection string from the Neon Console with connection pooling turned off, then run pg_dump -Fc -v -d with that string and -f with an output filename. Neon's docs warn that pooled connections cause errors. Use a pg_dump version that matches your project's Postgres version, and send the file to storage outside Neon.
How long are Neon scheduled snapshots kept?
At most 35 days, whatever the frequency. Backup schedules run daily, weekly or monthly on paid plans, and retention is set per schedule, from 1 hour up to that 35-day ceiling. Neon keeps the most recent scheduled snapshot while the schedule stays active, so you never drop to zero. Manual snapshots are the exception: they never expire unless you set an expiry, but they are capped at 100 per project on paid plans and 1 on Free.
Does a monthly Neon backup schedule keep a year of backups?
No. The 35-day ceiling applies to monthly schedules too, so each monthly snapshot is deleted about five days after the next one arrives. At any time you hold the latest month, and two snapshots only briefly. A weekly schedule holds about five snapshots and a daily one about 35. Combining frequencies, which the CLI and API allow, still stops at 35 days. A year of monthly restore points means taking manual snapshots yourself, or keeping pg_dump copies outside Neon.
Can I restore a Neon backup to a different Postgres provider?
Only from a logical backup. Instant restore and snapshots restore inside Neon. A pg_dump file in custom format restores into any Postgres host with pg_restore, as long as the target runs the same or a newer major version. This portability is the main reason to keep pg_dump backups alongside Neon's native recovery.
Glossary
Neon reuses some Postgres words with a narrower meaning and adds a few of its own. A root branch is not simply the first branch, and a snapshot is not a file you can download. These are the definitions this guide uses.
- Root branch
- A Neon branch with no parent, usually production. Instant restore, manual snapshots and backup schedules work on root branches only, so a restore plan that depends on a child branch does not work.
- History window
- How far back Neon keeps the change history of a project: 6 hours on Free, up to 7 days on Launch, up to 30 days on Scale. It bounds both instant restore and Time Travel queries.
- Instant restore
- Neon's point-in-time restore. It rewrites a root branch to its state at a chosen timestamp or LSN inside the history window, and keeps the pre-restore state as a backup branch named {branch}_old_{timestamp}.
- Snapshot
- A point-in-time capture of a root branch, stored inside the Neon project. Manual snapshots persist until you delete them or they reach an expiry you set; scheduled snapshots are kept for up to 35 days.
- Backup schedule
- Neon's automatic snapshots, set per root branch on paid plans: daily at an hour, weekly on a day, or monthly on a date. Each schedule has its own retention, capped at 35 days, so a weekly schedule holds about five snapshots and a monthly one holds the latest month.
- Time Travel
- Read-only queries against a past state of a branch, inside the history window, run through a temporary branch. Useful for checking what a table looked like before you decide to restore.
- LSN (Log Sequence Number)
- A position in the Postgres write-ahead log. Neon lets you restore to an exact LSN rather than a timestamp, which matters when two changes happened in the same second.
- Unpooled connection
- A direct connection to a Neon compute, without the PgBouncer pooler in front. pg_dump and pg_restore need it: Neon's docs warn that pooled connections cause errors.
- Logical backup
- A backup that captures the database as SQL and data, produced by pg_dump. It restores into any Postgres host of the same or a newer major version, which makes it the only portable format for a Neon database.
- Off-site backup
- A copy stored outside the system it protects, under separate credentials. For Neon, that means outside the Neon account: object storage you own, in a region and provider you choose.
- RPO / RTO
- Recovery Point Objective is how much data you can afford to lose, measured in time. Recovery Time Objective is how long you can afford to be down while restoring. Neon's instant restore gives an excellent RPO inside the history window and no RPO at all outside it.
Neon runs Postgres, so everything about pg_dump formats, flags and restore errors applies here too. That is covered in depth in the complete guide to PostgreSQL backup.
Keep instant restore for the bad migration at 14:02. SimpleBackups for Neon adds the copy that lives outside your Neon account: a scheduled pg_dump to storage you choose, retention set in months rather than days, and an alert when a run fails.
Neon changes plans and limits often. Every figure on this page was checked against Neon's docs on 3 November 2026. If one has moved since, tell us at hello@simplebackups.com and we will correct it and re-date the page.