Skip to content

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

PlanScheduled backupsKeptOn-demand backups kept
Freenone3 days
Proevery 6 hours48 hours; the first of each day 7 days7 days
Scaleevery hour48 hours; the first of each day 30 days30 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.failed alert 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 /restores with {"backup_id", "database_name"}, then poll GET /restores/{id} until succeeded or failed.
  • CLI: namidb restores create <backup-id> <new-database> --wait.
  • SDKs: restores.create with the backup id and the new name.
  • Terraform: namidb_database with restore_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:

SourceWhat you get
Latest backup (default)The newest finished backup. Fast to start; holds nothing newer than that backup.
Fresh snapshotA backup taken now, then copied. Holds everything committed up to the start of the snapshot.
Point in timeThe 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 /restores with {"database": "movies", "at": "2026-11-02T09:30:00Z", "database_name": "movies-before-incident"}, or the same as a clone, POST /databases/{database}/clones with {"name": "movies-before-incident", "source": "point_in_time", "at": "2026-11-02T09:30:00Z"}. Both answer a clone; poll GET /clones/{id}.
  • CLI: namidb restores create movies movies-before-incident --at 2026-11-02T09:30:00Z --wait, or --at 2h for two hours ago.
  • SDKs: restores.pointInTime (JavaScript) and restores.point_in_time (Python).
  • Terraform: namidb_database with clone_from = { database = "movies", at = "…" }.

What the clone reports:

FieldMeaning
statussnapshotting while the point in time is copied, then restoring, then succeeded or failed
recovery_pointThe moment the new database holds. Changes after it are not included. Null until the copy exists
recovery_sourcerestore_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:

PlanRestore-point window (exact, to the second)Before the window
FreenoneYour on-demand backups (kept 3 days)
Prolast 48 hoursOne backup a day, for 7 days
Scalelast 7 daysOne 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 backups30 per hour
Restores and clones together20 per hour
Running backupsone 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.