> 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/issues/ignore-or-restore-broken-link-issues/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 issues

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

Mutes broken link issues you decided not to fix (`ignored: true`), so they no longer count as open issues, or brings muted ones back (`ignored: false`). The change is immediate: the answer lists the issues that changed and the ones left out, so there is nothing to follow up.

Only existence is validated. Issues 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` (an issue your token cannot reach, with a null `site_name`), `NOT_FOUND` (an issue already resolved: the crawler no longer finds it) and `ALREADY_APPLIED` (an issue already in the requested state).

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

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

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

## 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)
- `issues` (list of double, optional)

## Response

### 200

200 - One ignored, one skipped

- `jsonapi` (ApiPublicV1SiteBrokenLinkIssuesBulkIgnorePatchResponsesContentApplicationJsonSchemaJsonapi, optional)
- `meta` (ApiPublicV1SiteBrokenLinkIssuesBulkIgnorePatchResponsesContentApplicationJsonSchemaMeta, optional)

## Errors

### 422 Unprocessable Entity Error

422 - Unknown finding id

- `errors` (list of ApiPublicV1SiteBrokenLinkIssuesBulkIgnorePatchResponsesContentApplicationJsonSchemaErrorsItems, optional)
- `jsonapi` (ApiPublicV1SiteBrokenLinkIssuesBulkIgnorePatchResponsesContentApplicationJsonSchemaJsonapi, optional)

## Types

### ApiPublicV1SiteBrokenLinkIssuesBulkIgnorePatchResponsesContentApplicationJsonSchemaJsonapi

- `version` (string, optional)

### ApiPublicV1SiteBrokenLinkIssuesBulkIgnorePatchResponsesContentApplicationJsonSchemaMeta

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

### ApiPublicV1SiteBrokenLinkIssuesBulkIgnorePatchResponsesContentApplicationJsonSchemaErrorsItems

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

### ApiPublicV1SiteBrokenLinkIssuesBulkIgnorePatchResponsesContentApplicationJsonSchemaMetaSkippedItems

- `issue_id` (integer, optional) — Id of an issue left out.
- `message` (string, optional) — Human-readable explanation.
- `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 issue left out.
- `site_name` (string, optional, nullable) — Name of that website; null when the id is outside your token's reach.

### ApiPublicV1SiteBrokenLinkIssuesBulkIgnorePatchResponsesContentApplicationJsonSchemaMetaUpdatedItems

- `issue_id` (integer, optional) — Id of an issue that changed.
- `site_id` (integer, optional) — Id of the website the issue belongs to.
- `site_name` (string, optional) — Name of that website.

### ApiPublicV1SiteBrokenLinkIssuesBulkIgnorePatchResponsesContentApplicationJsonSchemaErrorsItemsSource

- `parameter` (string, optional)

## Examples

### 200 - One ignored, one skipped

**Response**

```json
{
  "jsonapi": {
    "version": "1.1"
  },
  "meta": {
    "skipped": [
      {
        "issue_id": 702,
        "message": "This finding is already ignored.",
        "reason_code": "ALREADY_APPLIED",
        "site_id": 12,
        "site_name": "Example site"
      }
    ],
    "status": "applied",
    "updated": [
      {
        "issue_id": 701,
        "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-issues/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-issues/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-issues/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-issues/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-issues/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-issues/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-issues/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-issues/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 issues

**Request**

```json
{
  "ignored": true,
  "issues": [
    701,
    702
  ]
}
```

**Response**

```json
{
  "jsonapi": {
    "version": "1.1"
  },
  "meta": {
    "skipped": [
      {
        "issue_id": 702,
        "message": "This finding is already ignored.",
        "reason_code": "ALREADY_APPLIED",
        "site_id": 12,
        "site_name": "Example site"
      }
    ],
    "status": "applied",
    "updated": [
      {
        "issue_id": 701,
        "site_id": 12,
        "site_name": "Example site"
      }
    ]
  }
}
```

**SDK Code**

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

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

payload = {
    "ignored": True,
    "issues": [701, 702]
}
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 issues
const url = 'https://api.modulards.com/api/public/v1/site-broken-link-issues/bulk-ignore';
const options = {
  method: 'PATCH',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"ignored":true,"issues":[701,702]}'
};

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 issues
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"ignored\": true,\n  \"issues\": [\n    701,\n    702\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 issues
require 'uri'
require 'net/http'

url = URI("https://api.modulards.com/api/public/v1/site-broken-link-issues/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  \"issues\": [\n    701,\n    702\n  ]\n}"

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

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

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

$client = new \GuzzleHttp\Client();

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

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

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

var client = new RestClient("https://api.modulards.com/api/public/v1/site-broken-link-issues/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  \"issues\": [\n    701,\n    702\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

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

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "ignored": true,
  "issues": [701, 702]
] 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-issues/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()
```