Backups, restores, clones and point in time
Durability first
Every write NamiDB acknowledges is already stored in your organization’s
storage. Losing the engine, or a restart, loses nothing that was
acknowledged. Backups are for the other kind of loss: a bad migration, a
DETACH DELETE without a WHERE, an application bug, or wanting yesterday’s
data next to today’s.
Backups
| Plan | Scheduled backups | Kept | On-demand backups kept |
|---|---|---|---|
| Free | none | 3 days | |
| Pro | every 6 hours | 48 hours; the first of each day 7 days | 7 days |
| Scale | every hour | 48 hours; the first of each day 30 days | 30 days |
- A backup is a full, consistent snapshot of one database, stored in your organization’s own storage. It counts as storage while it is kept. Each backup records when its newest change was committed, so a restore from it states exactly what it holds.
- On demand on every plan: database page → Backups → Back up now
(owners, admins and developers),
POST /databases/{database}/backups,namidb backups create <db> --wait. One backup per database runs at a time (409 backup_in_progress); at most 30 on-demand backups per organization per hour. - Each backup shows its kind (manual or scheduled), status, size and expiry.
A failed scheduled backup is retried at the next slot, and the
backup.failedalert tells you about it.
Restore
A restore copies a backup into a new database. It never overwrites an existing one, so you can compare, copy what you need back, or switch your application over to it.
- Console: Backups → Restore on a backup, then name the new database.
- API:
POST /restoreswith{"backup_id", "database_name"}, then pollGET /restores/{id}untilsucceededorfailed. - CLI:
namidb restores create <backup-id> <new-database> --wait. - SDKs:
restores.createwith the backup id and the new name. - Terraform:
namidb_databasewithrestore_from_backup_id.
The new database is restoring (queries answer 503 database_unavailable)
until the copy is done, and it counts against your plan’s database limit.
The time a restore takes grows with the database’s size.
To put the restored data back under the original name: delete the original, then restore again into the freed name, or point your application at the new database.
Clones
A clone is a new database with the contents of an existing one. Choose the source:
| Source | What you get |
|---|---|
| Latest backup (default) | The newest finished backup. Fast to start; holds nothing newer than that backup. |
| Fresh snapshot | A backup taken now, then copied. Holds everything committed up to the start of the snapshot. |
| Point in time | The database as it was at a time you pick: see Point-in-time restore. |
Use clones for staging copies, testing a migration on real data, or
analytics that should not compete with production. Console: database page →
Clone. API: POST /databases/{database}/clones with {"name", "source"}
(latest_backup, fresh_snapshot or point_in_time with at). CLI:
namidb databases clone movies movies-staging --source fresh_snapshot --wait.
Terraform: namidb_database with clone_from.
Point-in-time restore
Pick a time and NamiDB creates a new database holding the original as it was at that time.
- Inside the restore-point window (the last 48 hours on Pro, the last 7 days on Scale) the copy is exact to the second: every change committed at or before the time you pick, and none after it.
- Before the window, and on Free, NamiDB copies the newest backup that holds nothing committed after that time. Before you confirm, the console shows that backup’s recovery point: the new database holds the original exactly as it was at that moment, so changes between the recovery point and the time you picked are not included.
Ways to start one:
- Console: database page → Restore to a point in time.
- API:
POST /restoreswith{"database": "movies", "at": "2026-11-02T09:30:00Z", "database_name": "movies-before-incident"}, or the same as a clone,POST /databases/{database}/cloneswith{"name": "movies-before-incident", "source": "point_in_time", "at": "2026-11-02T09:30:00Z"}. Both answer a clone; pollGET /clones/{id}. - CLI:
namidb restores create movies movies-before-incident --at 2026-11-02T09:30:00Z --wait, or--at 2hfor two hours ago. - SDKs:
restores.pointInTime(JavaScript) andrestores.point_in_time(Python). - Terraform:
namidb_databasewithclone_from = { database = "movies", at = "…" }.
What the clone reports:
| Field | Meaning |
|---|---|
status | snapshotting while the point in time is copied, then restoring, then succeeded or failed |
recovery_point | The moment the new database holds. Changes after it are not included. Null until the copy exists |
recovery_source | restore_point (an exact copy from the window) or backup (the newest backup at or before the time) |
A time inside the window that the restore points don’t reach yet falls back
to a backup, and recovery_source and recovery_point say so. That happens
for a while after restore points start for a database: after an upgrade from
Free, the window fills up over the next 48 hours (Pro) or 7 days (Scale).
An exact copy is kept in the database’s backup list as a point_in_time
backup (with as_of, the instant it holds) for as long as an on-demand
backup, and it counts toward the backups per hour below.
Errors: 400 bad_request for a time in the future; 409 no_backup_before
when nothing covers that time; 409 no_backup when the database has no
backup at all. If the point in time could not be copied and no backup covers
it either, the clone and its new database fail, and the backup.failed
alert tells you.
What recovery point to expect
The recovery point objective (RPO) is how much recent work a restore can miss. Inside the restore-point window it is zero for the time you pick: the copy holds every change committed by then. Outside it, it is set by the backup schedule:
| Plan | Restore-point window (exact, to the second) | Before the window |
|---|---|---|
| Free | none | Your on-demand backups (kept 3 days) |
| Pro | last 48 hours | One backup a day, for 7 days |
| Scale | last 7 days | One backup a day, for 30 days |
A restore never includes changes made after the time you pick, nor anything from a time no restore point or backup covers. If you want a fixed copy before a risky change, take an on-demand backup (or a fresh-snapshot clone) right before it: it is kept after the window has moved on.
Storage. Keeping the restore-point window means keeping the database’s recent history: about what the database writes during the window, on top of its live data. It is measured and billed as storage, like the database and its backups.
Limits
| Per organization | |
|---|---|
| On-demand, clone and point-in-time backups | 30 per hour |
| Restores and clones together | 20 per hour |
| Running backups | one per database at a time |
Restores, clones and point-in-time restores need the same role as creating a database (owners, admins and developers), and the second factor when you have one enrolled.
Off the platform
For a copy outside NamiDB Cloud, use an export: JSON Lines files and a Cypher script you can keep anywhere and load into NamiDB or Neo4j.