# Website Change Monitor & Diff Checker (`maximedupre/webpage-diff-checker`) Actor

Check public webpages against saved baselines. Find text, HTML, SEO metadata, semantic data, and link changes, with clear details for each change.

- **URL**: https://apify.com/maximedupre/webpage-diff-checker.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 page checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### 🔎 Find webpage changes without checking by hand

Webpage Diff Checker is for SEO teams, developers, and site owners who track public pages. It compares each page with its last good baseline and returns added or removed text, metadata and link changes, severity, and key page facts.

- **[Website change monitoring](https://apify.com/maximedupre/webpage-diff-checker/examples/website-change-monitoring)** — check public pages again and see what changed.
- **[Webpage diff checking](https://apify.com/maximedupre/webpage-diff-checker/examples/webpage-diff-checker)** — compare visible text or HTML with the last good baseline.
- **[Competitor page monitoring](https://apify.com/maximedupre/webpage-diff-checker/examples/competitor-page-monitoring)** — watch public product, feature, and news pages.
- **[SEO metadata change tracking](https://apify.com/maximedupre/webpage-diff-checker/examples/seo-metadata-change-tracking)** — find changes to titles, descriptions, canonical links, hreflang, and robots rules.
- **[Structured data change monitoring](https://apify.com/maximedupre/webpage-diff-checker/examples/structured-data-change-monitoring)** — track JSON-LD, microdata, RDFa, and Open Graph changes.
- **[Website link change tracking](https://apify.com/maximedupre/webpage-diff-checker/examples/website-link-change-tracking)** — find internal and external links that were added or removed.
- **[Pricing page change monitoring](https://apify.com/maximedupre/webpage-diff-checker/examples/pricing-page-change-monitoring)** — focus on price words or a CSS section.
- **[Policy page change monitoring](https://apify.com/maximedupre/webpage-diff-checker/examples/policy-page-change-monitoring)** — keep separate named baselines for terms and policy pages.

#### 📦 Returned data

Each saved dataset row is one page that was fetched and checked. It includes:

- requested and final URL, check time, HTTP status, response time, redirect state, page size, and content fingerprint
- `new`, `unchanged`, or `changed` status
- a short summary, change magnitude, severity, and categories
- added and removed text, plus watched keywords found in the changes
- SEO and semantic metadata changes with before and after values
- internal and external links added or removed

The run summary also gives totals for checked, changed, new, unchanged, and failed pages. Failed pages include error details there. A failed fetch does not replace the last good baseline.

#### 🚀 Running the Actor

1. Add one or more public HTTP or HTTPS webpage URLs.
2. Give the monitor a stable name so it keeps its own baselines.
3. Choose visible text or HTML. You can also pick a CSS section or content scope.
4. Add watched keywords or rules that remove known page noise if needed.
5. Choose all page rows or only new and changed pages. Failed checks stay in the run summary.
6. Run the Actor. Run the same setup again to compare with the saved baseline.

The first successful check for a page creates its baseline. Later successful checks compare with it and then save the new good baseline.

#### 🧾 Input

`urls` is required. Public options also include `monitorName`, `comparisonType`, `cssSelector`, `contentScope`, `watchedKeywords`, `excludedPageParts`, `excludedSelectors`, `excludedPatterns`, `proxyConfiguration`, and `resultMode`.

```json
{
  "urls": [
    { "url": "https://example.com/" },
    { "url": "https://www.iana.org/help/example-domains" }
  ],
  "monitorName": "public-pages",
  "comparisonType": "visibleText",
  "contentScope": "mainContent",
  "watchedKeywords": ["price", "policy"],
  "excludedPageParts": ["headers", "footers"],
  "resultMode": "changedOnly"
}
````

Use a different `monitorName` for each separate set of baselines. The Actor checks public pages only. It does not log in to private pages or make screenshot or pixel diffs.

#### 📤 Output

A changed page row can look like this:

```json
{
  "requestedUrl": "https://example.com/news",
  "finalUrl": "https://www.example.com/news",
  "status": "changed",
  "checkedAt": "2026-07-21T10:15:30.000Z",
  "httpStatus": 200,
  "responseTimeMs": 384,
  "redirected": true,
  "contentSizeBytes": 18420,
  "fingerprint": "sha256:2cf24dba5fb0a30e",
  "change": {
    "summary": "The page title changed and a pricing section was added.",
    "magnitude": 0.18,
    "severity": "medium",
    "categories": ["content", "seo"],
    "addedText": ["Plans start at $20."],
    "removedText": ["Contact us for pricing."],
    "watchedKeywords": ["price"]
  },
  "metadataChanges": [
    { "kind": "title", "name": "title", "before": "News", "after": "Product news" }
  ],
  "linkChanges": {
    "addedInternal": ["https://www.example.com/pricing"],
    "removedInternal": [],
    "addedExternal": [],
    "removedExternal": []
  }
}
```

Open the dataset for page rows. Open the output key-value store record for run totals and failure details.

#### 💳 Pricing

This Actor uses pay-per-event pricing. One `Page check` event is charged for each webpage that is successfully fetched and checked for changes. Failed fetches and failure details do not create this event. Check the Pricing tab for current tier prices.

#### 🔌 Integrations

Use Apify datasets, the API, schedules, webhooks, and platform integrations to run repeat checks and send the output to your workflow.

https://www.youtube.com/watch?v=bNACk1\_S\_6w\&list=PLObrtcm1Kw6MUrlLNDbK9QRg8VDJg0gOW\&index=4

#### ❓ FAQ

##### What happens on the first run?

The first successful check creates a new baseline. There is no older page content to compare yet.

##### What happens if a page fails to load?

The run summary lists the failure and its details. The Actor keeps the last good baseline, so a failed page does not become the next comparison source.

##### How can I avoid cookie banners and changing counters?

Common changing noise is cleaned on its own. You can also leave out common page parts, CSS selectors, or text matched by regex patterns.

##### Can I watch only one part of a page?

Yes. Add a `cssSelector`, or choose main content or article content as the content scope.

##### Can it check private pages or compare screenshots?

No. It checks public HTTP and HTTPS pages without a login. It compares visible text or HTML, not pixels or screenshots.

##### Can it find old versions from the Internet Archive?

No. It compares repeat checks made with this Actor. Use Wayback Machine Search when you need saved Internet Archive history.

##### Should I use one monitor name for every task?

Use one stable name for each monitor. Give separate tasks different names so their baselines do not replace one another.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~webpage-diff-checker/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Related Actors

- [Webpage Text Extractor](https://apify.com/maximedupre/webpage-text-extractor) — extract clean text or Markdown from public pages.
- [Website URL Crawler & Link Extractor](https://apify.com/maximedupre/website-url-crawler) — build the URL list for a site before you monitor chosen pages.
- [Wayback Machine Search](https://apify.com/maximedupre/wayback-machine-search) — find older page snapshots from the Internet Archive.
- [Seobility SEO Checker](https://apify.com/maximedupre/seobility-seo-checker) — run a current on-page SEO audit alongside change tracking.
- [Sitemap Sniffer](https://apify.com/maximedupre/sitemap-sniffer) — find public sitemap files and page URLs to check.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `urls` (type: `array`):

Add the public HTTP or HTTPS webpages to check.

## `monitorName` (type: `string`):

Give this monitor a stable name. Use a different name for each set of baselines.

## `comparisonType` (type: `string`):

Choose the page content to compare between runs.

## `contentScope` (type: `string`):

Choose the page area to compare. Main content skips common headers, menus, sidebars, and footers. Article content uses the main article or post.

## `cssSelector` (type: `string`):

Compare only the first page section that matches this CSS selector. Leave this blank to use the content scope.

## `watchedKeywords` (type: `array`):

Add words or phrases that matter most. Change details give more focus to text that includes them.

## `excludedPageParts` (type: `array`):

Choose common page parts to remove before content is compared.

## `excludedSelectors` (type: `array`):

Add CSS selectors for page elements to remove before content is compared.

## `excludedPatterns` (type: `array`):

Add regex patterns for changing text to remove before content is compared. Example: Updated at .\*

## `resultMode` (type: `string`):

Choose whether to return every successful page check or only pages that are new or changed.

## Actor input object example

```json
{
  "urls": [
    {
      "url": "https://example.com/"
    }
  ],
  "monitorName": "default",
  "comparisonType": "visibleText",
  "contentScope": "wholePage",
  "resultMode": "all"
}
```

# Actor output Schema

## `results` (type: `string`):

Open successful webpage checks with change details and page data.

## `summary` (type: `string`):

Open totals for checked, changed, new, unchanged, and failed webpages. It also has failure details and severity totals.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        {
            "url": "https://example.com/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/webpage-diff-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "urls": [{ "url": "https://example.com/" }] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/webpage-diff-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    {
      "url": "https://example.com/"
    }
  ]
}' |
apify call maximedupre/webpage-diff-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/webpage-diff-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Change Monitor & Diff Checker",
        "description": "Check public webpages against saved baselines. Find text, HTML, SEO metadata, semantic data, and link changes, with clear details for each change.",
        "version": "0.0",
        "x-build-id": "0nn6maXdVS1MHlL3V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~webpage-diff-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-webpage-diff-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/maximedupre~webpage-diff-checker/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-webpage-diff-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/maximedupre~webpage-diff-checker/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-webpage-diff-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "Webpage URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Add the public HTTP or HTTPS webpages to check.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "The public HTTP or HTTPS webpage URL.",
                                    "pattern": "^https?://[^\\s]+$"
                                }
                            },
                            "required": [
                                "url"
                            ],
                            "additionalProperties": false
                        }
                    },
                    "monitorName": {
                        "title": "Monitor name",
                        "minLength": 1,
                        "maxLength": 100,
                        "type": "string",
                        "description": "Give this monitor a stable name. Use a different name for each set of baselines.",
                        "default": "default"
                    },
                    "comparisonType": {
                        "title": "Compare",
                        "enum": [
                            "visibleText",
                            "html"
                        ],
                        "type": "string",
                        "description": "Choose the page content to compare between runs.",
                        "default": "visibleText"
                    },
                    "contentScope": {
                        "title": "Content scope",
                        "enum": [
                            "wholePage",
                            "mainContent",
                            "articleContent"
                        ],
                        "type": "string",
                        "description": "Choose the page area to compare. Main content skips common headers, menus, sidebars, and footers. Article content uses the main article or post.",
                        "default": "wholePage"
                    },
                    "cssSelector": {
                        "title": "CSS section",
                        "minLength": 1,
                        "maxLength": 500,
                        "type": "string",
                        "description": "Compare only the first page section that matches this CSS selector. Leave this blank to use the content scope."
                    },
                    "watchedKeywords": {
                        "title": "Watched keywords",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add words or phrases that matter most. Change details give more focus to text that includes them.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 200
                        }
                    },
                    "excludedPageParts": {
                        "title": "Page parts to leave out",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose common page parts to remove before content is compared.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "headers",
                                "navigation",
                                "sidebars",
                                "footers",
                                "cookieBanners",
                                "popups",
                                "forms"
                            ],
                            "enumTitles": [
                                "Headers",
                                "Menus and navigation",
                                "Sidebars",
                                "Footers",
                                "Cookie banners",
                                "Popups",
                                "Forms"
                            ]
                        }
                    },
                    "excludedSelectors": {
                        "title": "CSS selectors to leave out",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add CSS selectors for page elements to remove before content is compared.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 500
                        }
                    },
                    "excludedPatterns": {
                        "title": "Text patterns to leave out",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Add regex patterns for changing text to remove before content is compared. Example: Updated at .*",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 500
                        }
                    },
                    "resultMode": {
                        "title": "Results",
                        "enum": [
                            "all",
                            "changedOnly"
                        ],
                        "type": "string",
                        "description": "Choose whether to return every successful page check or only pages that are new or changed.",
                        "default": "all"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```