# Start a new server from a snapshot

> Order a server that is built with a snapshot's software and restored from it as soon as the install finishes.

Source: https://docs.coritan.com/snapshots/new-server-from-a-snapshot/

In the dashboard:

- /dashboard/servers/…/snapshots: https://www.coritan.com/dashboard/servers

An order can name one of your snapshots. We then install the new server with the software the snapshot was taken on, and restore the snapshot onto it as soon as the install finishes, so the new server starts as a copy of the old one. Use it to move a world to another location or a larger plan, or to bring back a server you deleted.

The server order page on coritan.com has no place to name a snapshot, so you place this order with the API. In the dashboard, [order a server](/managed-containers/order-a-server/) with the same software and then [restore the snapshot onto it](/snapshots/restore-a-snapshot/).

## Before you begin

- The snapshot must be on your account, with the status `Completed`. The [Snapshots](https://www.coritan.com/dashboard/snapshots) page lists every snapshot you have.
- The plan's disk must hold the restored files. We compare it with the larger of two figures: the snapshot's size, and the disk the old server used when we took the snapshot.
- You need an access token for the API ([Authentication](/api/authentication/)), and the `product_id` and `pricing_id` of the plan ([Order a service](/get-started/order-a-service/#with-the-api)).
- A snapshot holds the server's files only. Its [databases](/managed-containers/databases/) do not come with it, so plan to create them again on the new server.

## Order a server from a snapshot

1. List your snapshots and copy the `uuid` of the one to start from:

   ```bash
   curl https://api.coritan.com/api/v1/client/snapshots \
     -H "Authorization: Bearer $CORITAN_TOKEN"
   ```

   Check that its `status` is `completed`. `size_bytes` and `source_used_bytes` show how much disk the new plan needs.
2. Place the order with the snapshot's `uuid` in `config.restore_snapshot_uuid`:

   ```bash
   curl -X POST https://api.coritan.com/api/v1/services/order \
     -H "Authorization: Bearer $CORITAN_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
       "product_id": 12,
       "pricing_id": 34,
       "hostname": "survival-smp",
       "idempotency_key": "4a8e2c61-9f3b-4d7a-b5e0-8c1f2a3d6e97",
       "config": {
         "location": "fra",
         "name": "survival-smp",
         "specialization_slug": "minecraft-paper",
         "restore_snapshot_uuid": "5f0c9a2e-7b1d-4e8a-9c3f-2a6d8e1b4c70"
       }
     }'
   ```

   Send `specialization_slug` with the software the old server ran. When the snapshot records its software (its `software_slug` is set), we install that software and version and ignore the software fields in the order. When it records none, we install what the order names.
3. When the response has `requires_payment` set to `true`, pay the invoice it names in `invoice_id` ([Pay an invoice](/billing/invoices/#with-the-api)). We start setting up the server once the invoice is paid.

## Follow the restore

1. In the [dashboard](https://www.coritan.com/dashboard/servers), go to **Container Apps** and open the new server, then its **Snapshots** tab.
2. Read the card at the top of the tab. The tab refreshes by itself while the restore waits or runs.
   - **Waiting to restore your snapshot**: we are still installing the server.
   - **Restoring your snapshot**: we are writing the snapshot's files onto the server.
   - **Restored from a snapshot**: the files are in place. The card gives the date.
   - **Could not restore the snapshot**: the restore failed, and the card gives the reason. Select **Try again** to run it again.
3. When the card shows **Restored from a snapshot**, open the **Console** tab and select **Start**. The server does not start by itself.

The restore deletes the files the install wrote and puts the snapshot's files in their place. It goes ahead when the server runs different software for the same game, such as Fabric for a Paper world, but plugins or mods then do not carry over. It never restores a snapshot of a different game. While it runs, the snapshot shows `Restoring` on the **Snapshots** page, and it stays on your account afterwards.

To move a world, check that the new server runs as you expect before you [cancel the old one](/billing/cancel-a-service/).

## Result

The new server shows **Restored from a snapshot** on its **Snapshots** tab and holds the old server's files. Its address and port are new, so send your players the address that **Copy address** at the top of the server page copies.

## Troubleshooting

When the order names a snapshot it cannot use, the API answers `422` and places no order. `detail.errors` holds one of these messages:

`That snapshot is not on this account, so a server cannot be created from it.`
: The `uuid` is wrong, or another account holds the snapshot. Copy the `uuid` from your own list of snapshots.

`That snapshot is creating and cannot be restored yet. Wait for it to finish, then order again.`
: The message names the snapshot's status. Wait until it is `completed`, then place the order again. A `failed` snapshot cannot be used.

A message that starts `This snapshot needs about`
: The plan's disk is too small for the snapshot, for example `This snapshot needs about 2048 MB of disk and this plan has 1024 MB. Pick a larger plan to restore it.` Order a plan with more disk.

`Only game server snapshots can seed a new server.`
: The snapshot is not of a Container Apps server.

`Snapshots are not enabled on this platform yet, so a server cannot be created from one.`
: Snapshots are switched off for now. Order the server without `restore_snapshot_uuid`, or [contact support](/support/conversations/).

When the restore fails after the order, the card on the **Snapshots** tab shows **Could not restore the snapshot** with one of these reasons:

`The snapshot was deleted before it could be restored.`
: Someone deleted the snapshot while the server was installing. We cannot bring it back, so **Try again** fails too. Set up the server by hand, or restore another snapshot onto it.

`That snapshot is not on this account, so a server cannot be created from it.`
: The snapshot was deleted, or no longer qualified, before we set up the server. We built the server anyway, with the software the order carried. Restore another snapshot onto it, or set it up by hand.

A reason that starts `The daemon`
: The machine the server runs on did not finish the restore. Select **Try again**. If it fails again, [contact support](/support/conversations/).

A reason that ends `Restore it onto a server running the same game.`
: The snapshot records no software, and the order installed software for a different game. Restore the snapshot onto a server that runs the same game ([Restore a snapshot onto a server](/snapshots/restore-a-snapshot/)).

The card stays on **Waiting to restore your snapshot**
: The install is still running, or it failed. After a failed install, the restore waits and runs once an install succeeds ([The install failed](/managed-containers/troubleshooting/#the-install-failed)).

The server holds the snapshot's files but will not start
: Read the console output. [The server crashed or stopped](/managed-containers/troubleshooting/#the-server-crashed-or-stopped) covers the usual causes.

## Related

- [Restore a snapshot onto a server](/snapshots/restore-a-snapshot/)
- [Order a server](/managed-containers/order-a-server/)
- [Order a service](/get-started/order-a-service/)
- [Take a server snapshot](/managed-containers/snapshots/)

## With the API

`GET /api/v1/client/servers/{uuid}/snapshots/seed` returns the restore a server ordered from a snapshot is waiting on, or had. It returns `null` for a server ordered without one.

```bash
curl https://api.coritan.com/api/v1/client/servers/$SERVER/snapshots/seed \
  -H "Authorization: Bearer $CORITAN_TOKEN"
```

```json
{
  "uuid": "9b1d3f5a-7c2e-4a6b-8d0f-1e3a5c7b9d2f",
  "snapshot_uuid": "5f0c9a2e-7b1d-4e8a-9c3f-2a6d8e1b4c70",
  "snapshot_name": "before-1.21-update",
  "snapshot_software_label": "Paper 1.21.4",
  "snapshot_size_bytes": 1932735283,
  "status": "completed",
  "error": null,
  "attempts": 1,
  "created_at": "2026-09-20T09:12:04",
  "started_at": "2026-09-20T09:15:40",
  "finished_at": "2026-09-20T09:18:02"
}
```

`status`
: `pending` while the server installs, `restoring` while we write the files, then `completed` or `failed`.

`error`
: Why the restore failed, the same reason the card shows.

`attempts`
: How many times the restore has run, counting each **Try again**.

`snapshot_name`, `snapshot_software_label` and `snapshot_size_bytes`
: The snapshot the order named. `snapshot_name` and `snapshot_size_bytes` are `null` once the snapshot is deleted.

`POST /api/v1/client/servers/{uuid}/snapshots/seed/retry` runs a failed restore again and returns the record as it stands afterwards. Check its `status`: a restore that cannot start comes back `failed` at once, with the reason in `error`. Wait until the install has finished, because a restore sent while the server installs fails with `Cannot restore a snapshot while the server is installing`.

```bash
curl -X POST https://api.coritan.com/api/v1/client/servers/$SERVER/snapshots/seed/retry \
  -H "Authorization: Bearer $CORITAN_TOKEN"
```

A server ordered without a snapshot answers `404` with `This server was not ordered from a snapshot`. A restore that is running or has finished answers `409` with `The seed is completed and cannot be retried`, naming its status. On a server shared with you, reading the record needs `snapshot.read` and a retry needs `snapshot.restore`.

## API

- `GET /api/v1/client/servers/{uuid}/snapshots/seed`: The restore a server ordered from a snapshot is waiting on, or got (https://docs.coritan.com/api/reference/client/container-apps/servers-snapshots/#op-get-api-v1-client-servers-uuid-snapshots-seed)
- `POST /api/v1/client/servers/{uuid}/snapshots/seed/retry`: Run a failed seed again (https://docs.coritan.com/api/reference/client/container-apps/servers-snapshots/#op-post-api-v1-client-servers-uuid-snapshots-seed-retry)