# UK BESS Pipeline Tracker (REPD) (`codeclouds/uk-bess-repd-tracker`) Actor

Tracks the UK battery energy storage system (BESS) planning pipeline via the official Renewable Energy Planning Database (REPD), with diff-based change detection per project.

- **URL**: https://apify.com/codeclouds/uk-bess-repd-tracker.md
- **Developed by:** [Dennis](https://apify.com/codeclouds) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 40.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 project-updates

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## UK BESS Pipeline Tracker (REPD)

Structured, diff-based tracking of the UK battery energy storage system (BESS) planning pipeline, built on
the official Renewable Energy Planning Database (REPD) — new and changed projects delivered per run, never
a flat, unfiltered CSV dump.

### When should an AI agent use this?

- "Which UK BESS projects have changed planning status since last month?"
- "Show me all operational battery storage projects in Scotland over 50MW."
- "Which local planning authorities have the most BESS applications in the pipeline?"
- "Alert me when a new BESS project is submitted for planning in the South West."
- "What's the current UK BESS pipeline in the Awaiting Construction / Under Construction stages?"

### What this Actor does

- Downloads the official quarterly REPD extract (gov.uk, Open Government Licence) directly — no scraping.
- Filters it down to battery energy storage projects only (REPD's `Technology Type == "Battery"` rows,
  covering both standalone BESS and storage co-located with e.g. a solar farm).
- Normalizes each project into a flat, consistent JSON record (capacity, status, region, planning authority,
  coordinates, operator).
- Detects new and changed projects between runs (status change, capacity change) using a persisted snapshot
  — you only pay for what actually changed, never for re-delivering the same unchanged project. The
  snapshot survives runs where a project temporarily falls outside your filters, and bridges REPD's own
  Ref ID renumbering when a project is resubmitted, so a continuing project is never mistaken for a new one.
- Resolves a battery's co-located generation project (e.g. the solar farm it shares a site with) to its
  name, technology and capacity via REPD's own cross-reference, instead of just a free-text label.
- Delivers a free batch summary record per run (totals by status/region, total MW pipeline) alongside the
  per-project results, at no extra charge.

### Input

| Field | Type | Description |
|---|---|---|
| `region` | array of strings | Optional: only include projects in these REPD regions (e.g. `"Scotland"`, `"Wales"`, `"Northern Ireland"`, `"South West"`). |
| `minCapacityMW` | integer | Optional: minimum installed capacity in MW. |
| `maxCapacityMW` | integer | Optional: maximum installed capacity in MW. |
| `status` | array of strings | Optional: only include projects with one of these development statuses (e.g. `"Application Submitted"`, `"Under Construction"`, `"Operational"`). |
| `planningAuthority` | array of strings | Optional: only include projects handled by these local planning authorities (e.g. `"Cotswold"`, `"Fife Council"`). |
| `onlyChangedSinceLastRun` | boolean | Default `true`. If `false`, delivers the full filtered snapshot every run (still only charges for new/changed projects). |

### Output

```json
{
  "projectId": "6845",
  "projectName": "AES Kilroot Station Battery Storage Array",
  "coLocatedWith": "Co-located with fossil fuel plant",
  "coLocatedProject": {
    "refId": "1867",
    "name": "Morris Fen (PV)",
    "technologyType": "Solar Photovoltaics",
    "capacityMW": 27
  },
  "operator": "AES Kilroot Power (AES KPL)",
  "capacityMW": 10,
  "capacityMWh": null,
  "status": "Operational",
  "statusHistory": [
    { "status": "Under Construction", "date": "2026-04-12T09:00:00.000Z" },
    { "status": "Operational", "date": "2026-07-17T11:29:52.970Z" }
  ],
  "region": "Northern Ireland",
  "country": "Northern Ireland",
  "planningAuthority": "Mid and East Antrim",
  "postCode": "BT38 7LX",
  "osgb36Easting": "157517",
  "osgb36Northing": "543117",
  "sourceRecordLastUpdated": "12/12/2018",
  "isNewSinceLastRun": false,
  "isChangedSinceLastRun": true,
  "previousStatus": "Under Construction",
  "refIdChangedFrom": null,
  "operatorChanged": false,
  "previousOperator": null,
  "sourceUrl": "https://assets.publishing.service.gov.uk/media/.../REPD_publication_Q1_2026.csv",
  "scrapedAt": "2026-07-17T11:29:52.970Z"
}
````

`coLocatedProject` is `null` when the battery is standalone or when REPD's own cross-reference doesn't
resolve to another project. `refIdChangedFrom` is only set when this project is recognised as a
continuation of an earlier REPD Ref ID (see FAQ). `operatorChanged`/`previousOperator` flag an
ownership/operator change since your previous run — a separate signal from a status/capacity change.

Note: REPD does not publish an MWh (energy capacity) field alongside MW (power capacity) — `capacityMWh`
is always `null`, an honest limitation of the source data, not a bug. Coordinates are the source's native
OSGB36 British National Grid easting/northing (not converted to latitude/longitude, to avoid introducing an
unverified projection error).

### Use cases

- BESS developers and EPCs scanning regional competition/market density.
- Fire-safety and planning consultancies selling pipeline intelligence to developers.
- Investors/funds scanning BESS project dealflow by region and status.
- Grid connection and interconnection consultants.
- Insurers/underwriters tracking BESS risk portfolios.

### Pricing

This Actor uses Apify's Pay-Per-Event (PPE) pricing model.

- **Actor Start:** $0.00005 (Apify default)
- **`project-update`:** $0.02 — charged for each new or changed BESS project detected since your previous
  run. Never charged for unchanged projects or for a run with no changes.
- **`colocation-resolved`:** $0.01 — charged alongside `project-update`, only when the delivered project's
  co-located generation project could be resolved to a name/technology/capacity.
- **`ownership-change`:** $0.03 — charged alongside `project-update`, only when the operator/applicant of a
  project has changed since your previous run.

### Legal

Source: the Renewable Energy Planning Database (REPD), published by the UK Department for Energy Security
and Net Zero via gov.uk, licensed under the Open Government Licence v3.0. All data is at project level
(operator/applicant is typically a company, not an individual) — no personal data is processed.

### FAQ

**Q: How often is the data updated?**
A: REPD is published quarterly (in the month following each quarter's end). Running this Actor more often
than that will not surface new projects, only re-confirm the same snapshot.

**Q: Does this include Ireland or the Isle of Man?**
A: No — REPD covers England, Scotland, Wales and Northern Ireland only.

**Q: Why is capacity sometimes missing?**
A: Some early-stage projects (e.g. `Application Submitted`) do not yet have a confirmed installed capacity
in REPD; these are delivered with `capacityMW: null` rather than a guessed value.

**Q: Does this cover other grid storage technologies like pumped hydro or compressed air?**
A: No — this Actor tracks battery energy storage (BESS) specifically (REPD's `Technology Type == "Battery"`
rows). Pumped Storage Hydroelectricity, Liquid Air Energy Storage and Compressed Air Energy Storage are
separate REPD technology types and are intentionally out of scope.

**Q: What happens if REPD gives a project a new Ref ID after resubmission?**
A: REPD itself tracks this via an "Are they re-applying" field. This Actor uses that to recognise the
project as a continuation rather than a brand-new one, carrying its status history forward and never
double-billing it as new.

**Q: How do I catch M\&A activity in the BESS pipeline?**
A: Watch for `operatorChanged: true` — this fires whenever the operator/applicant on a project changes
between runs, independent of any status or capacity change, and is billed separately (`ownership-change`).

### Keywords

uk, battery storage, bess, repd, renewable energy planning database, grid, energy storage, planning pipeline

### Changelog

#### 0.4.0

- **Breaking output schema change**: renamed several Dutch-language output field names to English
  (e.g. `capaciteitMW`→`capacityMW`, `statusHistorie`→`statusHistory`, `isNieuwSindsVorigeRun`→
  `isNewSinceLastRun`, `bronUrl`→`sourceUrl`, `datumOpgehaald`→`scrapedAt` — see full list in
  PROJECTINFORMATIE.txt). This Actor's audience reads English, not Dutch. If you have an existing
  integration reading the old field names, update it before using this version.

#### 0.3.0

- Fixed: a battery row whose co-location reference (incorrectly) pointed to itself no longer shows
  itself as its own `coLocatedProject`.
- Added a cap on `statusHistory` length (most recent 20 entries) so a single flapping project cannot
  grow the stored history unbounded.
- Added operator/ownership-change detection (`operatorChanged`/`previousOperator`) — new `ownership-change`
  event, a dedicated M\&A/dealflow signal independent of status/capacity changes.
- Added retry-with-backoff test coverage (was previously untested).

#### 0.2.0

- Fixed a bug where the change-detection snapshot was fully overwritten each run instead of merged,
  which could cause a project to be re-billed as "new" after temporarily falling outside your filters.
- Fixed a bug where a first run with zero matching projects could make the *next* run also skip billing.
- Added Ref ID continuity handling so a project resubmitted under a new REPD Ref ID is recognised as a
  continuation, not a new project.
- Added `statusHistory` (full status history) to each record.
- Added co-located project resolution (`coLocatedProject`) — new `colocation-resolved` event.
- Added a free per-run batch summary record (totals by status/region, total MW pipeline).
- Added `planningAuthority` input filter.
- Added retry with backoff on the REPD download.

#### 0.1.0

- Initial release.

# Actor input Schema

## `region` (type: `array`):

Optional: only include projects in these REPD regions (e.g. "Scotland", "Wales", "Northern Ireland", "South West"). Leave empty for all UK regions.

## `minCapacityMW` (type: `integer`):

Optional: only include projects with an installed capacity of at least this many MW.

## `maxCapacityMW` (type: `integer`):

Optional: only include projects with an installed capacity of at most this many MW.

## `status` (type: `array`):

Optional: only include projects with one of these REPD development statuses (e.g. "Application Submitted", "Awaiting Construction", "Under Construction", "Operational"). Leave empty for all statuses.

## `planningAuthority` (type: `array`):

Optional: only include projects handled by these local planning authorities (e.g. "Cotswold", "Fife Council"). Leave empty for all authorities.

## `onlyChangedSinceLastRun` (type: `boolean`):

If true (default), only projects that are new or changed since the previous run are delivered and charged. If false, the full filtered snapshot is delivered every run, but only new/changed projects are still charged. Uses a shared, persistent key-value store snapshot ('uk-bess-repd-tracker-snapshot') that is also read and updated by scheduled monitoring runs, not just this one. On the very first call ever (no snapshot exists yet), there is nothing to compare against: every project in the filtered set is treated as new, so the entire filtered snapshot is delivered and charged that first time regardless of this setting.

## Actor input object example

```json
{
  "onlyChangedSinceLastRun": true
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("codeclouds/uk-bess-repd-tracker").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("codeclouds/uk-bess-repd-tracker").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 '{}' |
apify call codeclouds/uk-bess-repd-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=codeclouds/uk-bess-repd-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UK BESS Pipeline Tracker (REPD)",
        "description": "Tracks the UK battery energy storage system (BESS) planning pipeline via the official Renewable Energy Planning Database (REPD), with diff-based change detection per project.",
        "version": "0.4",
        "x-build-id": "U95UKYd9HFbdJFHTz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/codeclouds~uk-bess-repd-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-codeclouds-uk-bess-repd-tracker",
                "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/codeclouds~uk-bess-repd-tracker/runs": {
            "post": {
                "operationId": "runs-sync-codeclouds-uk-bess-repd-tracker",
                "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/codeclouds~uk-bess-repd-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-codeclouds-uk-bess-repd-tracker",
                "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",
                "properties": {
                    "region": {
                        "title": "Region filter",
                        "type": "array",
                        "description": "Optional: only include projects in these REPD regions (e.g. \"Scotland\", \"Wales\", \"Northern Ireland\", \"South West\"). Leave empty for all UK regions.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minCapacityMW": {
                        "title": "Minimum capacity (MW)",
                        "type": "integer",
                        "description": "Optional: only include projects with an installed capacity of at least this many MW."
                    },
                    "maxCapacityMW": {
                        "title": "Maximum capacity (MW)",
                        "type": "integer",
                        "description": "Optional: only include projects with an installed capacity of at most this many MW."
                    },
                    "status": {
                        "title": "Development status filter",
                        "type": "array",
                        "description": "Optional: only include projects with one of these REPD development statuses (e.g. \"Application Submitted\", \"Awaiting Construction\", \"Under Construction\", \"Operational\"). Leave empty for all statuses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "planningAuthority": {
                        "title": "Planning authority filter",
                        "type": "array",
                        "description": "Optional: only include projects handled by these local planning authorities (e.g. \"Cotswold\", \"Fife Council\"). Leave empty for all authorities.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "onlyChangedSinceLastRun": {
                        "title": "Only deliver new/changed projects",
                        "type": "boolean",
                        "description": "If true (default), only projects that are new or changed since the previous run are delivered and charged. If false, the full filtered snapshot is delivered every run, but only new/changed projects are still charged. Uses a shared, persistent key-value store snapshot ('uk-bess-repd-tracker-snapshot') that is also read and updated by scheduled monitoring runs, not just this one. On the very first call ever (no snapshot exists yet), there is nothing to compare against: every project in the filtered set is treated as new, so the entire filtered snapshot is delivered and charged that first time regardless of this setting.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```