> 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/broken-links-checker/pages/ignore-or-restore-broken-link-pages/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://api.docs.modulards.com/_mcp/server.

# Ignore or restore broken link pages

PATCH https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore
Content-Type: application/json

Mutes broken link pages you decided not to fix (`ignored: true`): their issues are detached and the page is no longer re-checked; or brings muted pages back (`ignored: false`). Ignoring a page detaches every issue still attached to it in the same call; restoring does not reattach them: the next scan that visits the page finds its issues again. The change is immediate: the answer lists the pages that changed and the ones left out, so there is nothing to follow up.

Only existence is validated. Pages that cannot be changed are reported in `meta.skipped`, each with a `reason_code` and a message, and do not fail the call: `PERMISSION_DENIED` (a page your token cannot reach, with a null `site_name`), `NOT_FOUND` (a page already resolved: gone from the website) and `ALREADY_APPLIED` (a page already in the requested state).

**Body**
- `pages` (array of integers, required): ids of the pages to change, 1 to 50, no duplicates.
- `ignored` (boolean, required): `true` ignores the pages, `false` restores them.

**Errors**
- **422**: an id does not exist.

Reference: https://api.docs.modulards.com/modular-ds-public-api/broken-links-checker/pages/ignore-or-restore-broken-link-pages

## Authentication

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

## Request

### Body (application/json)

This endpoint expects an object.

- `ignored` (boolean, optional)
- `pages` (list of double, optional)

## Response

### 200

200 - One ignored, one skipped

- `jsonapi` (ApiPublicV1SiteBrokenLinkPagesBulkIgnorePatchResponsesContentApplicationJsonSchemaJsonapi, optional)
- `meta` (ApiPublicV1SiteBrokenLinkPagesBulkIgnorePatchResponsesContentApplicationJsonSchemaMeta, optional)

## Errors

### 422 Unprocessable Entity Error

422 - Unknown page id

- `errors` (list of ApiPublicV1SiteBrokenLinkPagesBulkIgnorePatchResponsesContentApplicationJsonSchemaErrorsItems, optional)
- `jsonapi` (ApiPublicV1SiteBrokenLinkPagesBulkIgnorePatchResponsesContentApplicationJsonSchemaJsonapi, optional)

## Types

### ApiPublicV1SiteBrokenLinkPagesBulkIgnorePatchResponsesContentApplicationJsonSchemaJsonapi

- `version` (string, optional)

### ApiPublicV1SiteBrokenLinkPagesBulkIgnorePatchResponsesContentApplicationJsonSchemaMeta

- `skipped` (list of ApiPublicV1SiteBrokenLinkPagesBulkIgnorePatchResponsesContentApplicationJsonSchemaMetaSkippedItems, optional)
- `status` (enum, optional) — Outcome of the call: applied when at least one page changed, skipped when none did.
  - Allowed values: `applied`, `skipped`
- `updated` (list of ApiPublicV1SiteBrokenLinkPagesBulkIgnorePatchResponsesContentApplicationJsonSchemaMetaUpdatedItems, optional)

### ApiPublicV1SiteBrokenLinkPagesBulkIgnorePatchResponsesContentApplicationJsonSchemaErrorsItems

- `detail` (string, optional)
- `source` (ApiPublicV1SiteBrokenLinkPagesBulkIgnorePatchResponsesContentApplicationJsonSchemaErrorsItemsSource, optional)
- `status` (string, optional)
- `title` (string, optional)

### ApiPublicV1SiteBrokenLinkPagesBulkIgnorePatchResponsesContentApplicationJsonSchemaMetaSkippedItems

- `message` (string, optional) — Human-readable explanation.
- `page_id` (integer, optional) — Id of a page left out.
- `reason_code` (enum, optional) — Why it was left out: NOT_FOUND (already resolved), ALREADY_APPLIED or PERMISSION_DENIED.
  - Allowed values: `NOT_FOUND`, `ALREADY_APPLIED`, `PERMISSION_DENIED`
- `site_id` (integer, optional) — Id of the website of a page left out.
- `site_name` (string, optional, nullable) — Name of that website; null when the id is outside your token's reach.

### ApiPublicV1SiteBrokenLinkPagesBulkIgnorePatchResponsesContentApplicationJsonSchemaMetaUpdatedItems

- `page_id` (integer, optional) — Id of a page that changed.
- `site_id` (integer, optional) — Id of the website the page belongs to.
- `site_name` (string, optional) — Name of that website.

### ApiPublicV1SiteBrokenLinkPagesBulkIgnorePatchResponsesContentApplicationJsonSchemaErrorsItemsSource

- `parameter` (string, optional)

## Examples

### 200 - One ignored, one skipped

**Response**

```json
{
  "jsonapi": {
    "version": "1.1"
  },
  "meta": {
    "skipped": [
      {
        "message": "This page no longer exists on the website; it was not touched.",
        "page_id": 502,
        "reason_code": "NOT_FOUND",
        "site_id": 12,
        "site_name": "Example site"
      }
    ],
    "status": "applied",
    "updated": [
      {
        "page_id": 501,
        "site_id": 12,
        "site_name": "Example site"
      }
    ]
  }
}
```

**SDK Code**

```python 200 - One ignored, one skipped
import requests

url = "https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore"

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

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

print(response.json())
```

```javascript 200 - One ignored, one skipped
const url = 'https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore';
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 - One ignored, one skipped
package main

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

func main() {

	url := "https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore"

	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 - One ignored, one skipped
require 'uri'
require 'net/http'

url = URI("https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore")

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 - One ignored, one skipped
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-broken-link-pages/bulk-ignore")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php 200 - One ignored, one skipped
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp 200 - One ignored, one skipped
using RestSharp;

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

```swift 200 - One ignored, one skipped
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore")! 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()
```

### Ignore or restore broken link pages

**Request**

```json
{
  "ignored": true,
  "pages": [
    501,
    502
  ]
}
```

**Response**

```json
{
  "jsonapi": {
    "version": "1.1"
  },
  "meta": {
    "skipped": [
      {
        "message": "This page no longer exists on the website; it was not touched.",
        "page_id": 502,
        "reason_code": "NOT_FOUND",
        "site_id": 12,
        "site_name": "Example site"
      }
    ],
    "status": "applied",
    "updated": [
      {
        "page_id": 501,
        "site_id": 12,
        "site_name": "Example site"
      }
    ]
  }
}
```

**SDK Code**

```python Ignore or restore broken link pages
import requests

url = "https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore"

payload = {
    "ignored": True,
    "pages": [501, 502]
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Ignore or restore broken link pages
const url = 'https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore';
const options = {
  method: 'PATCH',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"ignored":true,"pages":[501,502]}'
};

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

```go Ignore or restore broken link pages
package main

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

func main() {

	url := "https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore"

	payload := strings.NewReader("{\n  \"ignored\": true,\n  \"pages\": [\n    501,\n    502\n  ]\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 Ignore or restore broken link pages
require 'uri'
require 'net/http'

url = URI("https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore")

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  \"ignored\": true,\n  \"pages\": [\n    501,\n    502\n  ]\n}"

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

```java Ignore or restore broken link pages
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-broken-link-pages/bulk-ignore")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"ignored\": true,\n  \"pages\": [\n    501,\n    502\n  ]\n}")
  .asString();
```

```php Ignore or restore broken link pages
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore', [
  'body' => '{
  "ignored": true,
  "pages": [
    501,
    502
  ]
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Ignore or restore broken link pages
using RestSharp;

var client = new RestClient("https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore");
var request = new RestRequest(Method.PATCH);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"ignored\": true,\n  \"pages\": [\n    501,\n    502\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Ignore or restore broken link pages
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.modulards.com/api/public/v1/site-broken-link-pages/bulk-ignore")! 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()
```