# Utility Rebate Change Tracker (`springstea/utility-rebate-change-tracker`) Actor

Tracks changes in US utility & state energy incentive programs: rebate amount increases/decreases, new and removed programs, eligible equipment changes and date changes. Data source: DSIRE.

- **URL**: https://apify.com/springstea/utility-rebate-change-tracker.md
- **Developed by:** [Kasım Genç](https://apify.com/springstea) (community)
- **Categories:** Business, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Utility Rebate Change Tracker

Tracks changes in US utility & state energy incentive programs and reports them as structured change records:

- 💰 *"Texas heat pump rebate went from $1,500 to $2,000"* → `amount_increased`
- 🛠️ *"This HVAC model class is no longer eligible"* → `equipment_changed`
- 🆕 *"A new solar battery rebate program opened"* → `new_program`
- 🗑️ *"Program disappeared from the database"* → `program_removed`

**Data source:** [DSIRE](https://programs.dsireusa.org) (Database of State Incentives for Renewables & Efficiency, NC State University) — the authoritative database of US federal, state and utility energy incentive programs.

### How it works

1. On every run the Actor queries DSIRE for all programs matching your **regions** (US states) × **categories** (equipment/technology types).
2. Each program is normalized into a comparable snapshot: incentive amounts (from DSIRE parameter sets), eligible equipment, dates, budget, summary/detail hashes.
3. The snapshot is stored in a **named key-value store** (persists across runs). The next run diffs the fresh data against it and pushes one dataset record per changed program.
4. The first run for a given configuration establishes the baseline. With `emitBaselineRecords: true` (default) it also outputs every currently-active matched program with `changeType: "baseline"`, so you get the full picture immediately.

Schedule it (e.g. **daily or weekly** on the Apify platform) to get a continuous change feed. DSIRE program records are updated by analysts on weekdays, so daily is plenty.

### Input

```json
{
    "regions": ["Texas", "Utah"],
    "categories": ["hvac", "heat-pump", "solar", "battery"],
    "sectors": ["Residential"],
    "includeFederal": true,
    "emitBaselineRecords": true,
    "snapshotStoreName": "utility-rebate-tracker",
    "maxConcurrency": 4
}
````

| Field | Type | Description |
|---|---|---|
| `regions` \* | `string[]` | US states — full names (`"Texas"`) or 2-letter codes (`"TX"`). |
| `categories` \* | `string[]` | Category slugs (below), raw DSIRE technology ids (`"207"`), or exact DSIRE technology names (`"Solar Photovoltaics"`). |
| `sectors` | `string[]` | Optional sector filter: `Residential`, `Commercial`, `Industrial`, `Agricultural`, ... Empty = all. |
| `includeFederal` | `boolean` | Federal programs apply to every state; disable to track state/utility programs only. Default `true`. |
| `emitBaselineRecords` | `boolean` | Output all matched programs as `baseline` records on the first run. Default `true`. |
| `snapshotStoreName` | `string` | Named key-value store holding snapshots between runs. Default `utility-rebate-tracker`. |
| `maxConcurrency` | `integer` | Parallel DSIRE requests (1–10). Default `4`. |
| `proxyConfiguration` | `object` | Optional Apify proxy settings. |

#### Supported category slugs

`hvac`, `heat-pump`, `solar`, `battery` (aliases `storage`, `energy-storage`), `ev`, `ev-charging`, `water-heater`, `appliances`, `lighting`, `insulation`, `building-envelope`, `wind`, `geothermal`, `biomass`, `hydro`, `fuel-cells`, `whole-building`, plus the broad `energy-efficiency` and `renewables`.

Slugs are resolved against the **live** DSIRE technology list on every run, so newly added technologies (e.g. a new heat-pump subtype) are picked up automatically.

### Output

One dataset record per changed program. Example — a rebate amount increase:

```json
{
    "program": "Renewable Energy Systems Tax Credit (Corporate)",
    "programId": 248,
    "url": "https://programs.dsireusa.org/system/program/detail/248",
    "region": "Utah",
    "state": "UT",
    "sector": "Commercial",
    "programType": "Corporate Tax Credit",
    "administrator": "Utah Governor's Office of Energy Development",
    "categoriesMatched": ["solar", "heat-pump"],
    "eligibleEquipment": ["Geothermal Heat Pumps", "Solar Photovoltaics", "Solar Water Heat"],
    "changeType": "amount_increased",
    "oldAmount": 1100,
    "newAmount": 1600,
    "amountUnits": "$",
    "amountQualifier": null,
    "eligibleEquipmentChanged": false,
    "equipmentAdded": [],
    "equipmentRemoved": [],
    "incentiveAmountText": "$1,600 per residential unit",
    "maximumIncentiveText": "$1,600",
    "effectiveDate": "2007-01-01",
    "endDate": null,
    "lastUpdated": "September 30, 2025",
    "changes": [
        {
            "field": "amount",
            "kind": "amount_increased",
            "source": "Incentive",
            "qualifier": "",
            "units": "$",
            "old": 1100,
            "new": 1600,
            "description": "Amount ($) changed from 1100 to 1600"
        }
    ],
    "detectedAt": "2026-07-10T13:21:06.608Z",
    "source": "DSIRE (programs.dsireusa.org)"
}
```

#### `changeType` values

| Value | Meaning |
|---|---|
| `baseline` | First run for this configuration — current state of a program. |
| `new_program` | Program appeared that wasn't in the previous snapshot. |
| `program_removed` | Program disappeared from DSIRE results (ended/unpublished). |
| `amount_increased` / `amount_decreased` / `amount_changed` | An incentive amount changed (top-level `oldAmount`/`newAmount`/`amountUnits`). |
| `amount_added` / `amount_removed` | A new incentive amount line appeared / was dropped. |
| `equipment_changed` | Eligible equipment list changed (see `equipmentAdded`/`equipmentRemoved`). |
| `dates_changed` | Program start/end date changed (see `previousEffectiveDate`). |
| `program_renamed` | Program name changed. |
| `program_updated` | Other material change (summary, budget, funding source, incentive detail text, ...). |

Each record's `changes` array lists **every** field-level diff; `changeType` reflects the most significant one (amounts > equipment > dates > other).

A run summary is stored under the `OUTPUT` key of the default key-value store:

```json
{
    "isBaseline": false,
    "programsTracked": 116,
    "changesDetected": 5,
    "byChangeType": { "amount_increased": 1, "equipment_changed": 1, "new_program": 1 }
}
```

### Notes & limitations

- The snapshot key is derived from the resolved configuration (states × technologies × sectors). Changing the input creates a **new baseline** rather than producing false `program_removed` records.
- If any DSIRE request ultimately fails after retries, the run aborts **without** touching the stored snapshot, so a flaky run can't produce phantom changes.
- Many programs express incentives as text tiers (e.g. "6%–30% depending on labor factors") rather than clean numbers; those changes are still caught via the `Incentive Amount` / `Maximum Incentive` detail texts (`program_updated` with old/new text in `changes`).
- DSIRE covers the US only.

### Scheduling & integrations

Create a **daily or weekly Schedule** on the Apify platform to turn this Actor into a continuous change feed, and use Apify **integrations** (webhooks, Slack, email, Zapier/Make) to get notified the moment a rebate changes.

# Actor input Schema

## `regions` (type: `array`):

US states to track. Accepts full state names ("Texas") or 2-letter codes ("TX"). Federal programs that apply everywhere are included by default (see <b>Include federal programs</b>).

## `categories` (type: `array`):

Which incentive categories to track. Supported slugs: <code>hvac</code>, <code>heat-pump</code>, <code>solar</code>, <code>battery</code> (aka <code>storage</code>), <code>ev</code>, <code>ev-charging</code>, <code>water-heater</code>, <code>appliances</code>, <code>lighting</code>, <code>insulation</code>, <code>building-envelope</code>, <code>wind</code>, <code>geothermal</code>, <code>biomass</code>, <code>hydro</code>, <code>fuel-cells</code>, <code>whole-building</code>, <code>energy-efficiency</code> (broad), <code>renewables</code> (broad). You can also pass a raw DSIRE technology id (e.g. <code>207</code>) or an exact DSIRE technology name (e.g. <code>Solar Photovoltaics</code>).

## `sectors` (type: `array`):

Optional. Limit to specific sectors, e.g. <code>Residential</code>, <code>Commercial</code>, <code>Industrial</code>, <code>Agricultural</code>. Leave empty to track all sectors.

## `includeFederal` (type: `boolean`):

Federal programs (e.g. the federal tax credits) apply to every state, so DSIRE returns them for each state query. Turn off to track state/utility level programs only.

## `emitBaselineRecords` (type: `boolean`):

On the very first run there is nothing to compare against. When enabled, every matched program is pushed to the dataset with changeType <code>baseline</code> so you immediately get the full current picture. When disabled, the first run only stores the snapshot and outputs nothing.

## `snapshotStoreName` (type: `string`):

Name of the (named, persistent) key-value store where snapshots are kept between runs. Change it if you want independent tracking timelines.

## `maxConcurrency` (type: `integer`):

Number of parallel requests against the DSIRE API. Keep it low to be polite.

## `proxyConfiguration` (type: `object`):

Optional proxies for the DSIRE requests.

## Actor input object example

```json
{
  "regions": [
    "Texas",
    "Utah"
  ],
  "categories": [
    "hvac",
    "heat-pump",
    "solar",
    "battery"
  ],
  "sectors": [],
  "includeFederal": true,
  "emitBaselineRecords": true,
  "snapshotStoreName": "utility-rebate-tracker",
  "maxConcurrency": 4
}
```

# 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 = {
    "regions": [
        "Texas",
        "Utah"
    ],
    "categories": [
        "hvac",
        "heat-pump",
        "solar",
        "battery"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("springstea/utility-rebate-change-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 = {
    "regions": [
        "Texas",
        "Utah",
    ],
    "categories": [
        "hvac",
        "heat-pump",
        "solar",
        "battery",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("springstea/utility-rebate-change-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 '{
  "regions": [
    "Texas",
    "Utah"
  ],
  "categories": [
    "hvac",
    "heat-pump",
    "solar",
    "battery"
  ]
}' |
apify call springstea/utility-rebate-change-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=springstea/utility-rebate-change-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Utility Rebate Change Tracker",
        "description": "Tracks changes in US utility & state energy incentive programs: rebate amount increases/decreases, new and removed programs, eligible equipment changes and date changes. Data source: DSIRE.",
        "version": "0.1",
        "x-build-id": "fXJFyfFfjcMCXobud"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/springstea~utility-rebate-change-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-springstea-utility-rebate-change-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/springstea~utility-rebate-change-tracker/runs": {
            "post": {
                "operationId": "runs-sync-springstea-utility-rebate-change-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/springstea~utility-rebate-change-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-springstea-utility-rebate-change-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",
                "required": [
                    "regions",
                    "categories"
                ],
                "properties": {
                    "regions": {
                        "title": "Regions (US states)",
                        "type": "array",
                        "description": "US states to track. Accepts full state names (\"Texas\") or 2-letter codes (\"TX\"). Federal programs that apply everywhere are included by default (see <b>Include federal programs</b>).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Equipment / technology categories",
                        "type": "array",
                        "description": "Which incentive categories to track. Supported slugs: <code>hvac</code>, <code>heat-pump</code>, <code>solar</code>, <code>battery</code> (aka <code>storage</code>), <code>ev</code>, <code>ev-charging</code>, <code>water-heater</code>, <code>appliances</code>, <code>lighting</code>, <code>insulation</code>, <code>building-envelope</code>, <code>wind</code>, <code>geothermal</code>, <code>biomass</code>, <code>hydro</code>, <code>fuel-cells</code>, <code>whole-building</code>, <code>energy-efficiency</code> (broad), <code>renewables</code> (broad). You can also pass a raw DSIRE technology id (e.g. <code>207</code>) or an exact DSIRE technology name (e.g. <code>Solar Photovoltaics</code>).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sectors": {
                        "title": "Sectors",
                        "type": "array",
                        "description": "Optional. Limit to specific sectors, e.g. <code>Residential</code>, <code>Commercial</code>, <code>Industrial</code>, <code>Agricultural</code>. Leave empty to track all sectors.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeFederal": {
                        "title": "Include federal programs",
                        "type": "boolean",
                        "description": "Federal programs (e.g. the federal tax credits) apply to every state, so DSIRE returns them for each state query. Turn off to track state/utility level programs only.",
                        "default": true
                    },
                    "emitBaselineRecords": {
                        "title": "Emit baseline records on first run",
                        "type": "boolean",
                        "description": "On the very first run there is nothing to compare against. When enabled, every matched program is pushed to the dataset with changeType <code>baseline</code> so you immediately get the full current picture. When disabled, the first run only stores the snapshot and outputs nothing.",
                        "default": true
                    },
                    "snapshotStoreName": {
                        "title": "Snapshot store name",
                        "type": "string",
                        "description": "Name of the (named, persistent) key-value store where snapshots are kept between runs. Change it if you want independent tracking timelines.",
                        "default": "utility-rebate-tracker"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of parallel requests against the DSIRE API. Keep it low to be polite.",
                        "default": 4
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxies for the DSIRE requests."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```