> 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/updater/installed-items/summarize-site-items/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://api.docs.modulards.com/_mcp/server.

# Summarize site items

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

Returns totals of the items installed on your websites, per type (plugins, themes and WordPress versions) and for the websites themselves. Use it for an overview, for example how many plugins can be updated and how many have a known vulnerability, without listing every item.

The totals cover connected websites only and accept the same filters as "List site items", so items whose update notice is hidden are left out unless you send `filter[is_hidden]`. An item counts as updatable only when a newer version exists, its update notice is not hidden and its website accepts installs. Only `filter` is accepted: `sort`, `page`, `fields` and `include` answer `422`. The answer can be a few seconds behind the latest change.

Reference: https://api.docs.modulards.com/modular-ds-public-api/updater/installed-items/summarize-site-items

## 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) — Website ids. Several values match any of them.
- `filter[team][]` (string, optional) — Team ids. Several values match websites in any of these teams.
- `filter[tags][]` (string, optional) — Tag ids. Several values match websites carrying any of these tags.
- `filter[core_version][]` (string, optional) — Exact WordPress versions of the website, for example `6.8.1`. Several values match any of them.
- `filter[engine_version][]` (string, optional) — Exact PHP versions of the website, for example `8.2.27`. Several values match any of them.
- `filter[type][]` (string, optional) — Item types: `core`, `plugin` or `theme`. Several values match any of them.
- `filter[component]` (string, optional) — Component id: counts only the installs of one plugin, theme or WordPress version.
- `filter[status][]` (string, optional) — Item states: `active`, `inactive` or `uninstalled`. Several values match any of them.
- `filter[update_available]` (string, optional) — `1` for items with a newer version available, `0` for items that are up to date.
- `filter[updatable]` (string, optional) — `1` for items that can be updated now: a newer version exists, the update notice is not hidden and the website accepts installs. `0` for the rest.
- `filter[has_vulnerabilities]` (string, optional) — `1` for items whose installed version has a known vulnerability, `0` for items without one.
- `filter[is_hidden]` (string, optional) — `1` for items whose update notice is hidden, `0` for visible ones. Default: only visible items.
- `filter[s]` (string, optional) — Free-text search on the item's name.

## Response

### 200

200 - Site items summary

- `jsonapi` (ApiPublicV1SiteItemsSummaryGetResponsesContentApplicationJsonSchemaJsonapi, optional)
- `meta` (ApiPublicV1SiteItemsSummaryGetResponsesContentApplicationJsonSchemaMeta, optional)

## Types

### ApiPublicV1SiteItemsSummaryGetResponsesContentApplicationJsonSchemaJsonapi

- `version` (string, optional)

### ApiPublicV1SiteItemsSummaryGetResponsesContentApplicationJsonSchemaMeta

- `core` (ApiPublicV1SiteItemsSummaryGetResponsesContentApplicationJsonSchemaMetaCore, optional)
- `plugin` (ApiPublicV1SiteItemsSummaryGetResponsesContentApplicationJsonSchemaMetaPlugin, optional)
- `sites` (ApiPublicV1SiteItemsSummaryGetResponsesContentApplicationJsonSchemaMetaSites, optional)
- `theme` (ApiPublicV1SiteItemsSummaryGetResponsesContentApplicationJsonSchemaMetaTheme, optional)

### ApiPublicV1SiteItemsSummaryGetResponsesContentApplicationJsonSchemaMetaCore

- `has_vulnerabilities` (integer, optional) — Number of WordPress versions whose installed version has a known vulnerability.
- `total` (integer, optional) — Number of WordPress versions installed on the matching websites.
- `updatable` (integer, optional) — Number of WordPress versions that can be updated now: newer version, update notice not hidden, website accepts installs.

### ApiPublicV1SiteItemsSummaryGetResponsesContentApplicationJsonSchemaMetaPlugin

- `has_vulnerabilities` (integer, optional) — Number of plugins whose installed version has a known vulnerability.
- `total` (integer, optional) — Number of plugins installed on the matching websites.
- `updatable` (integer, optional) — Number of plugins that can be updated now: newer version, update notice not hidden, website accepts installs.

### ApiPublicV1SiteItemsSummaryGetResponsesContentApplicationJsonSchemaMetaSites

- `total` (integer, optional) — Number of websites that have matching items.
- `with_updates` (integer, optional) — Number of websites with at least one item that can be updated now.

### ApiPublicV1SiteItemsSummaryGetResponsesContentApplicationJsonSchemaMetaTheme

- `has_vulnerabilities` (integer, optional) — Number of themes whose installed version has a known vulnerability.
- `total` (integer, optional) — Number of themes installed on the matching websites.
- `updatable` (integer, optional) — Number of themes that can be updated now: newer version, update notice not hidden, website accepts installs.

## Examples

**Response**

```json
{
  "jsonapi": {
    "version": "1.1"
  },
  "meta": {
    "core": {
      "has_vulnerabilities": 0,
      "total": 12,
      "updatable": 2
    },
    "plugin": {
      "has_vulnerabilities": 1,
      "total": 48,
      "updatable": 6
    },
    "sites": {
      "total": 12,
      "with_updates": 7
    },
    "theme": {
      "has_vulnerabilities": 0,
      "total": 5,
      "updatable": 1
    }
  }
}
```

**SDK Code**

```python 200 - Site items summary
import requests

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

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

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

print(response.json())
```

```javascript 200 - Site items summary
const url = 'https://api.modulards.com/api/public/v1/site-items/summary';
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 items summary
package main

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

func main() {

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

	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 items summary
require 'uri'
require 'net/http'

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

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 items summary
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-items/summary")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php 200 - Site items summary
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

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

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

```csharp 200 - Site items summary
using RestSharp;

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

```swift 200 - Site items summary
import Foundation

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

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