> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://api.docs.modulards.com/modular-ds-public-api/backups/website-backups/set-or-unset-a-master-backup/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://api.docs.modulards.com/_mcp/server.

# Set or unset a master backup

PATCH https://api.modulards.com/api/public/v1/site-backups/{siteBackup}/favorite
Content-Type: application/json

Marks one backup as a master backup, or takes the mark off. A master backup is kept out of the retention policy, so it never expires while marked. You set the state explicitly, so repeating the call leaves the same state.

Your role must be allowed to mark backups; without it the request answers 404.

**Body**
- `favorite` (boolean, required): `true` marks the backup as a master backup, `false` takes the mark off.

**Errors**
- **400**: your plan's cap of master backups for that website is reached. The error names it and nothing changes.
- **422**: `favorite` is missing or not a boolean.

Reference: https://api.docs.modulards.com/modular-ds-public-api/backups/website-backups/set-or-unset-a-master-backup

## Authentication

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

## Request

### Path parameters

- `siteBackup` (string, required)

### Body (application/json)

This endpoint expects an object.

- `favorite` (boolean, optional)

## Response

### 200

200 - Site backup favorite updated

- `data` (ApiPublicV1SiteBackupsSiteBackupFavoritePatchResponsesContentApplicationJsonSchemaData, optional)
- `jsonapi` (ApiPublicV1SiteBackupsSiteBackupFavoritePatchResponsesContentApplicationJsonSchemaJsonapi, optional)

## Types

### ApiPublicV1SiteBackupsSiteBackupFavoritePatchResponsesContentApplicationJsonSchemaData

- `attributes` (ApiPublicV1SiteBackupsSiteBackupFavoritePatchResponsesContentApplicationJsonSchemaDataAttributes, optional)
- `id` (string, optional)
- `links` (ApiPublicV1SiteBackupsSiteBackupFavoritePatchResponsesContentApplicationJsonSchemaDataLinks, optional)
- `type` (string, optional)

### ApiPublicV1SiteBackupsSiteBackupFavoritePatchResponsesContentApplicationJsonSchemaJsonapi

- `version` (string, optional)

### ApiPublicV1SiteBackupsSiteBackupFavoritePatchResponsesContentApplicationJsonSchemaDataAttributes

- `attempts` (integer, optional) — Number of attempts made: 1 for the first run, plus one for each retry. A failed or stalled backup is retried automatically, up to 3 times (4 attempts in all), within 24 hours of its creation; after that it stays failed and reads 4.
- `backup_type` (enum, optional) — full or incremental.
  - Allowed values: `full`, `incremental`
- `comment` (string, optional, nullable) — Note written on the backup.
- `created_at` (string, optional)
- `is_favorite` (boolean, optional) — True for a master backup, kept out of the retention policy.
- `method` (enum, optional) — How the backup started: manual, or automatic for scheduled ones. force_first is the first automatic backup of a website.
  - Allowed values: `manual`, `automatic`, `force_first`
- `phase` (enum, optional) — State to read: in_progress while it runs, done for a usable backup, failed when it did not complete.
  - Allowed values: `in_progress`, `done`, `failed`, `excluded`
- `restored_at` (datetime, optional, nullable) — When the backup was last restored; null if it never was.
- `site_id` (integer, optional) — Id of the website the backup belongs to.
- `size` (integer, optional) — Size of the backup, in bytes.
- `status` (string, optional) — Raw processing step behind phase.
- `updated_at` (string, optional)

### ApiPublicV1SiteBackupsSiteBackupFavoritePatchResponsesContentApplicationJsonSchemaDataLinks

- `self` (string, optional)

## Examples

### 200 - Site backup favorite updated

**Response**

```json
{
  "data": {
    "attributes": {
      "attempts": 0,
      "backup_type": "full",
      "comment": null,
      "created_at": "2026-09-18T03:00:00.000000Z",
      "is_favorite": true,
      "method": "manual",
      "phase": "done",
      "restored_at": null,
      "site_id": 12,
      "size": 104857600,
      "status": "done",
      "updated_at": "2026-09-18T10:20:00.000000Z"
    },
    "id": "9001",
    "links": {
      "self": "{{base_url}}/api/public/v1/site-backups/9001"
    },
    "type": "site-backups"
  },
  "jsonapi": {
    "version": "1.1"
  }
}
```

**SDK Code**

```python 200 - Site backup favorite updated
import requests

url = "https://api.modulards.com/api/public/v1/site-backups/siteBackup/favorite"

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

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

print(response.json())
```

```javascript 200 - Site backup favorite updated
const url = 'https://api.modulards.com/api/public/v1/site-backups/siteBackup/favorite';
const options = {method: 'PATCH', 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 backup favorite updated
package main

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

func main() {

	url := "https://api.modulards.com/api/public/v1/site-backups/siteBackup/favorite"

	req, _ := http.NewRequest("PATCH", 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 backup favorite updated
require 'uri'
require 'net/http'

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

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

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

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

```java 200 - Site backup favorite updated
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

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

```php 200 - Site backup favorite updated
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

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

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

```csharp 200 - Site backup favorite updated
using RestSharp;

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

```swift 200 - Site backup favorite updated
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.modulards.com/api/public/v1/site-backups/siteBackup/favorite")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()
```

### Set or unset a master backup

**Request**

```json
{
  "favorite": true
}
```

**Response**

```json
{
  "data": {
    "attributes": {
      "attempts": 0,
      "backup_type": "full",
      "comment": null,
      "created_at": "2026-09-18T03:00:00.000000Z",
      "is_favorite": true,
      "method": "manual",
      "phase": "done",
      "restored_at": null,
      "site_id": 12,
      "size": 104857600,
      "status": "done",
      "updated_at": "2026-09-18T10:20:00.000000Z"
    },
    "id": "9001",
    "links": {
      "self": "{{base_url}}/api/public/v1/site-backups/9001"
    },
    "type": "site-backups"
  },
  "jsonapi": {
    "version": "1.1"
  }
}
```

**SDK Code**

```python Set or unset a master backup
import requests

url = "https://api.modulards.com/api/public/v1/site-backups/siteBackup/favorite"

payload = { "favorite": True }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())
```

```javascript Set or unset a master backup
const url = 'https://api.modulards.com/api/public/v1/site-backups/siteBackup/favorite';
const options = {
  method: 'PATCH',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"favorite":true}'
};

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

```go Set or unset a master backup
package main

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

func main() {

	url := "https://api.modulards.com/api/public/v1/site-backups/siteBackup/favorite"

	payload := strings.NewReader("{\n  \"favorite\": true\n}")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

```ruby Set or unset a master backup
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Patch.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"favorite\": true\n}"

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

```java Set or unset a master backup
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.patch("https://api.modulards.com/api/public/v1/site-backups/siteBackup/favorite")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"favorite\": true\n}")
  .asString();
```

```php Set or unset a master backup
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://api.modulards.com/api/public/v1/site-backups/siteBackup/favorite', [
  'body' => '{
  "favorite": true
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Set or unset a master backup
using RestSharp;

var client = new RestClient("https://api.modulards.com/api/public/v1/site-backups/siteBackup/favorite");
var request = new RestRequest(Method.PATCH);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"favorite\": true\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Set or unset a master backup
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["favorite": true] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.modulards.com/api/public/v1/site-backups/siteBackup/favorite")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```