> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://api.docs.modulards.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://api.docs.modulards.com/_mcp/server.

# List restorations

GET https://api.modulards.com/api/public/v1/site-restorations

Lists the restorations run from your backups, newest first. Use it to follow how a restoration is going or why it failed: `phase` is `in_progress`, `done`, `failed` or `excluded`, `status` is the raw step (download, unzip, move, database and so on), and a restoration that never finished before its `expired_at` reads `phase: failed`. `type` tells a restoration in place from the migration variants (`migration_same_domain`, `migration_new_domain`, `migration_existing_site`, `migration_staging`).

Restorations are read only by design: a restoration touches the customer's files and database, so it is started from the dashboard. Nothing in this API starts, cancels or downloads one.

Your role must be allowed to read restorations; without it the request answers 404.

Reference: https://api.docs.modulards.com/modular-ds-public-api/backups/restorations/list-restorations

## Authentication

- `Authorization` header (bearer token, required) — Personal access token created in the Modular DS dashboard; read-only tokens can only call GET endpoints.

## Request

### Query parameters

- `filter[site][]` (string, optional) — Exact website ids. Repeat the parameter for several: any of them matches.
- `filter[backup][]` (string, optional) — Exact backup ids: the restorations run from those backups. Repeat the parameter for several.
- `filter[id][]` (string, optional) — Exact restoration ids. Repeat the parameter for several.
- `filter[phase][]` (string, optional) — `in_progress`, `done`, `failed` or `excluded`. Repeat the parameter for several.
- `filter[status][]` (string, optional) — Raw processing steps, for when `phase` is not enough. Repeat the parameter for several.
- `filter[type][]` (string, optional) — `restoration`, `migration_same_domain`, `migration_new_domain`, `migration_existing_site` or `migration_staging`. Repeat the parameter for several.
- `include` (string, optional) — Relations to add to the answer, comma separated: `site` (the website) and `backup` (the backup the restoration came from).
- `sort` (string, optional) — `created_at` or `updated_at`; prefix with `-` for descending. Default: `-created_at` (newest first).
- `page[number]` (string, optional) — Page number, starting at 1. Default 1.
- `page[size]` (string, optional) — Items per page, 1 to 50. Default 15.

## Response

### 200

200 - Site restorations, one finished and one in progress

- `data` (list of ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaDataItems, optional)
- `jsonapi` (ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaJsonapi, optional)
- `links` (ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaLinks, optional)
- `meta` (ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaMeta, optional)

## Types

### ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaDataItems

- `attributes` (ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaDataItemsAttributes, optional)
- `id` (string, optional)
- `links` (ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaDataItemsLinks, optional)
- `type` (string, optional)

### ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaJsonapi

- `version` (string, optional)

### ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaLinks

- `first` (string, optional)
- `last` (string, optional)
- `next` (any, optional, nullable)
- `prev` (any, optional, nullable)

### ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaMeta

- `current_page` (double, optional)
- `from` (double, optional)
- `last_page` (double, optional)
- `links` (list of ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaMetaLinksItems, optional)
- `path` (string, optional)
- `per_page` (double, optional)
- `to` (double, optional)
- `total` (double, optional)

### ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaDataItemsAttributes

- `created_at` (string, optional)
- `created_by` (double, optional)
- `error_message` (any, optional, nullable)
- `expired_at` (string, optional)
- `phase` (enum, optional) — State to read: in_progress, done or failed. One that never finished before expired_at reads failed.
  - Allowed values: `in_progress`, `done`, `failed`, `excluded`
- `site_backup_id` (integer, optional) — Id of the backup that is restored.
- `status` (string, optional) — Raw step of the operation, for example a download, unzip, move or database step.
- `type` (enum, optional) — Kind of operation: restoration, or a migration to the same domain, to a new domain, to an existing website or to a staging website.
  - Allowed values: `restoration`, `migration_same_domain`, `migration_new_domain`, `migration_existing_site`, `migration_staging`
- `updated_at` (string, optional)
- `uri` (string, optional, nullable)

### ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaDataItemsLinks

- `self` (string, optional)

### ApiPublicV1SiteRestorationsGetResponsesContentApplicationJsonSchemaMetaLinksItems

- `active` (boolean, optional)
- `label` (string, optional)
- `url` (string, optional, nullable)

## Examples

**Response**

```json
{
  "data": [
    {
      "attributes": {
        "created_at": "2026-09-20T09:00:00.000000Z",
        "created_by": 34,
        "error_message": null,
        "expired_at": "2026-09-20T11:00:00.000000Z",
        "phase": "in_progress",
        "site_backup_id": 9002,
        "status": "move_progress",
        "type": "migration_new_domain",
        "updated_at": "2026-09-20T09:05:00.000000Z",
        "uri": "https://staging.acme.com"
      },
      "id": "502",
      "links": {
        "self": "{{base_url}}/api/public/v1/site-restorations/502"
      },
      "type": "site-restorations"
    },
    {
      "attributes": {
        "created_at": "2026-09-14T10:00:00.000000Z",
        "created_by": 34,
        "error_message": null,
        "expired_at": "2026-09-14T12:00:00.000000Z",
        "phase": "done",
        "site_backup_id": 9001,
        "status": "finished",
        "type": "restoration",
        "updated_at": "2026-09-14T10:18:00.000000Z",
        "uri": null
      },
      "id": "501",
      "links": {
        "self": "{{base_url}}/api/public/v1/site-restorations/501"
      },
      "type": "site-restorations"
    }
  ],
  "jsonapi": {
    "version": "1.1"
  },
  "links": {
    "first": "{{base_url}}/api/public/v1/site-restorations?page%5Bnumber%5D=1",
    "last": "{{base_url}}/api/public/v1/site-restorations?page%5Bnumber%5D=1",
    "next": null,
    "prev": null
  },
  "meta": {
    "current_page": 1,
    "from": 1,
    "last_page": 1,
    "links": [
      {
        "active": false,
        "label": "&laquo; Previous",
        "url": null
      },
      {
        "active": true,
        "label": "1",
        "url": "{{base_url}}/api/public/v1/site-restorations?page%5Bnumber%5D=1"
      },
      {
        "active": false,
        "label": "Next &raquo;",
        "url": null
      }
    ],
    "path": "{{base_url}}/api/public/v1/site-restorations",
    "per_page": 15,
    "to": 2,
    "total": 2
  }
}
```

**SDK Code**

```python 200 - Site restorations, one finished and one in progress
import requests

url = "https://api.modulards.com/api/public/v1/site-restorations"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript 200 - Site restorations, one finished and one in progress
const url = 'https://api.modulards.com/api/public/v1/site-restorations';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go 200 - Site restorations, one finished and one in progress
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.modulards.com/api/public/v1/site-restorations"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby 200 - Site restorations, one finished and one in progress
require 'uri'
require 'net/http'

url = URI("https://api.modulards.com/api/public/v1/site-restorations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java 200 - Site restorations, one finished and one in progress
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.modulards.com/api/public/v1/site-restorations")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php 200 - Site restorations, one finished and one in progress
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.modulards.com/api/public/v1/site-restorations', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp 200 - Site restorations, one finished and one in progress
using RestSharp;

var client = new RestClient("https://api.modulards.com/api/public/v1/site-restorations");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift 200 - Site restorations, one finished and one in progress
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.modulards.com/api/public/v1/site-restorations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```