# Power Grid Proximity Screener - Transmission Lines Near Sites (`malonestar/hifld-grid-proximity-screener`) Actor

Electric substation proximity API: for each site (lat/lon), get distance to the nearest substation, transmission line (kV, owner), and power plant, plus density counts and a HIGH/MEDIUM/LOW grid-access tier. Keyless HIFLD data. For data-center, renewable and BESS siting.

- **URL**: https://apify.com/malonestar/hifld-grid-proximity-screener.md
- **Developed by:** [Kyle Maloney](https://apify.com/malonestar) (community)
- **Categories:** Agents, Developer tools, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.50 / 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.
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

## Power Grid Proximity Screener — Lines, Substations & Power Plants Near Your Sites

Screens a list of sites (lat/lon) for grid access. For each one it finds the nearest in-service high-voltage transmission line (distance, voltage kV, class, owning utility), the nearest electric substation (distance, max voltage), and the nearest power plant (distance, capacity MW, fuel/type), counts how many of each fall within the search radius, and assigns a HIGH/MEDIUM/LOW grid-access tier you can sort a portfolio by. Built for data-center and renewable site selectors for whom power proximity is the gating constraint.

### How it works

For every asset, the actor runs a bounding-box query against three DHS HIFLD Open (Homeland Infrastructure Foundation-Level Data) ArcGIS layers — `Electric_Power_Transmission_Lines`, `Electric_Substations`, and `Power_Plants` — then computes distances locally: point-to-polyline haversine for lines, point-to-point haversine for substations and plants. One combined row is emitted per asset. A bad coordinate or an upstream lines-layer failure produces an `ERROR` row for that asset only; a substation- or power-plant-layer hiccup just leaves those fields null and the rest of the row is returned. No API key, no login.

Line distance is reported in miles; substation and power-plant distances are in kilometres. Set `includeSubstations` or `includePowerPlants` to false to skip either layer.

#### Grid-access tier (editorial model)

| Tier | Rule |
|---|---|
| HIGH | An existing line ≥ 230 kV within 2 miles |
| MEDIUM | Existing ≥ 115 kV within 2 miles, or ≥ 230 kV within 5 miles |
| LOW | Any existing line within the search radius |
| NONE | No existing line within the search radius |
| ERROR | Asset could not be screened (see `error`) |

"Existing" means energized lines, excluding those whose HIFLD STATUS marks them under construction, proposed, or retired. HIFLD leaves the STATUS of most in-service lines as `NOT AVAILABLE`, so this screener treats `NOT AVAILABLE` and unlabeled lines as existing — a strict "IN SERVICE"-only filter would wrongly report NONE next to real 230 kV lines. The tier is a heuristic for ranking sites, not an interconnection or hosting-capacity study.

### Example input

```json
{
  "assets": [
    { "lat": 39.7392, "lon": -104.9903, "label": "Denver site" },
    { "lat": 33.4484, "lon": -112.0740, "label": "Phoenix site" }
  ],
  "radiusMiles": 5,
  "minVoltageKv": 115,
  "includeSubstations": true,
  "includePowerPlants": true
}
````

### Output fields (one combined row per asset)

| Field | Meaning |
|---|---|
| `asset_label`, `asset_lat`, `asset_lon` | Your site, echoed back |
| `nearest_line_distance_miles` | Miles to the nearest existing (energized) transmission line |
| `nearest_line_voltage_kv` | Its voltage in kV (null when HIFLD doesn't report it) |
| `nearest_line_volt_class` | HIFLD voltage class, e.g. `100-161`, `345`, `UNDER 100` |
| `nearest_line_owner` | Owning utility |
| `nearest_line_status` | Raw HIFLD status (`NOT AVAILABLE` = unspecified, not out of service) |
| `lines_within_radius` | Line count within radius (after the `minVoltageKv` filter) |
| `lines_under_construction_within_radius` | Of those, how many are flagged under construction |
| `max_voltage_within_radius_kv` | Highest line voltage within the radius |
| `nearest_substation_name` / `_distance_km` / `_max_voltage` | Nearest electric substation |
| `substations_within_radius` | Substation count within radius |
| `nearest_power_plant_name` / `_distance_km` / `_fuel` / `_type` / `_capacity_mw` | Nearest power plant (fuel e.g. `NG`, `SUN`, `WND`, `COL`; type is the NAICS generation class) |
| `power_plants_within_radius` | Power-plant count within radius |
| `planned_line_nearby` | Low-confidence, non-authoritative hint (opt-in; see FAQ) |
| `grid_tier` | `HIGH` / `MEDIUM` / `LOW` / `NONE` / `ERROR` |
| `error`, `checked_at`, `source_url` | Error message, run timestamp, HIFLD source layer |

### Substation & power plant proximity

On by default since v1.1 (`includeSubstations` / `includePowerPlants`, both `true` unless explicitly set to `false`). For every asset the actor also returns the nearest HIFLD electric substation and the nearest power plant, each with a distance, so you get one API call that answers "how close is transmission, a substation, *and* generation" instead of three separate lookups.

**Who this is for:**

- **Data-center site selection** — substation proximity (and its `nearest_substation_max_voltage`) is often a harder gating constraint than the transmission line itself, since interconnection usually happens at a substation, not a bare line crossing.
- **Renewables & BESS interconnection pre-screening** — ranking parcels by distance to both a substation (likely point of interconnection) and existing generation (an early signal of hosting-capacity headroom on that part of the grid) before commissioning a full interconnection study.

**Example input (substation + power-plant screening explicitly on):**

```json
{
  "assets": [
    { "lat": 39.7392, "lon": -104.9903, "label": "Denver site" }
  ],
  "radiusMiles": 10,
  "includeSubstations": true,
  "includePowerPlants": true
}
```

**Output fields added by this screen:**

| Field | Meaning |
|---|---|
| `nearest_substation_name` | Name of the closest electric substation within radius |
| `nearest_substation_distance_km` | Distance to that substation in km |
| `nearest_substation_max_voltage` | Substation's max voltage in kV |
| `substations_within_radius` | Count of substations within radius |
| `nearest_power_plant_name` | Name of the closest power plant within radius |
| `nearest_power_plant_distance_km` | Distance to that plant in km |
| `nearest_power_plant_fuel` | Primary fuel (e.g. `NG`, `SUN`, `WND`, `COL`) |
| `nearest_power_plant_type` | NAICS generation type |
| `nearest_power_plant_capacity_mw` | Operating capacity in MW |
| `power_plants_within_radius` | Count of power plants within radius |

Set either flag to `false` to skip that layer and speed up large batch runs (fewer upstream queries per asset).

**FAQ**

**Is there a distance to nearest electric substation API?** Yes — every screened asset returns `nearest_substation_distance_km`, `nearest_substation_name`, and `nearest_substation_max_voltage`, sourced from HIFLD's Electric Substations layer, on by default.

**Can I do substation proximity screening for data centers in bulk?** Yes — submit up to 2,000 sites per run as `assets`, get back nearest substation, nearest power plant, nearest transmission line, and a HIGH/MEDIUM/LOW `grid_tier` for each, one row per site.

**Does it tell me how close a candidate parcel is to existing generation?** Yes — `nearest_power_plant_distance_km`, `nearest_power_plant_capacity_mw`, and `nearest_power_plant_fuel` report the closest power plant within the search radius, plus `power_plants_within_radius` for density.

### Who uses it

- Data-center site selectors screening candidate parcels for proximity to 230 kV+ lines, substations, and generation before spending on interconnection studies.
- Solar, wind, and BESS developers ranking parcels by distance to transmission and the voltage class they can realistically tie into.
- EV-charging network planners verifying grid presence around candidate hubs.
- Land agents adding grid-access, nearest-substation, and nearest-power-plant columns to listing sheets.
- Energy analysts looking at line density, ownership, and fuel mix around a point.

### Use as an MCP tool

A Pay-Per-Result API callable by AI agents through mcp.apify.com. Field-level output descriptions let an agent geocode candidate addresses, screen them, and rank by `grid_tier`, `nearest_line_distance_miles`, and `nearest_substation_distance_km` without glue code.

### FAQ

**Which sites can support a data center or battery project?** Sort by `grid_tier`, then `nearest_line_distance_miles` and `nearest_substation_distance_km`. HIGH-tier sites have 230 kV+ in-service transmission within 2 miles, and a nearby substation is a strong interconnection signal.

**Does it include planned transmission lines?** Only as an opt-in, non-authoritative hint. HIFLD's planned-line layer is an editable scratch layer with geometry only (no owner/voltage/status), so it is not a reliable planned-line dataset. Set `includePlanned: true` to populate `planned_line_nearby`, and treat it as a weak signal.

**Is the distance exact?** Distances use haversine math against HIFLD's published geometries, accurate to a few feet at screening scales.

**Where does the data come from?** DHS HIFLD Open ArcGIS: the `Electric_Power_Transmission_Lines`, `Electric_Substations`, and `Power_Plants` FeatureServer layers (public, keyless). This is advisory data — confirm with the utility before committing capital.

**How is it billed?** One result per screened asset (one combined row covering lines, substations, and plants).

# Actor input Schema

## `assets` (type: `array`):

Sites to screen for grid access. Each entry is an object { "lat": number, "lon": number, "label": "optional name" }. Also accepts "lat,lon" strings or \[lat, lon] arrays. One dataset row (one billed result) is produced per asset; a bad entry yields an ERROR row and the run continues.

## `radiusMiles` (type: `integer`):

Radius around each asset to search for transmission lines, substations and power plants, in miles (1-50). Features beyond this distance are ignored. Default 5.

## `minVoltageKv` (type: `integer`):

Optional. Only count/consider transmission lines with voltage at or above this many kV (e.g. 115 or 230). Lines with unknown voltage are excluded when set. Does not filter substations or power plants. Leave empty to include all lines.

## `includeSubstations` (type: `boolean`):

Also query the HIFLD Electric Substations layer and report the nearest substation (name, distance in km, max voltage) plus substations within the radius. On by default since v1.1 — set to false to skip substation screening and speed up large batches.

## `includePowerPlants` (type: `boolean`):

Also query the HIFLD Power Plants layer and report the nearest power plant (name, distance in km, fuel/type, capacity MW) plus power plants within the radius. On by default since v1.1 — set to false to skip power-plant screening and speed up large batches.

## `includePlanned` (type: `boolean`):

Advanced/opt-in. Also check a HIFLD 'planned transmission line' scratch layer that carries NO owner/voltage/status metadata. It is NOT an authoritative planned-line dataset — the planned\_line\_nearby flag is a low-confidence 'a planned-line geometry exists nearby' hint only. Default false.

## `maxResults` (type: `integer`):

Maximum number of assets processed in one run (1-2000). One result row is emitted (and billed) per asset. Default 500.

## Actor input object example

```json
{
  "assets": [
    {
      "lat": 39.7392,
      "lon": -104.9903,
      "label": "Denver site"
    },
    {
      "lat": 33.4484,
      "lon": -112.074,
      "label": "Phoenix site"
    }
  ],
  "radiusMiles": 5,
  "includeSubstations": true,
  "includePowerPlants": true,
  "includePlanned": false,
  "maxResults": 500
}
```

# Actor output Schema

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

The default dataset (one row per asset).

# 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 = {
    "assets": [
        {
            "lat": 39.7392,
            "lon": -104.9903,
            "label": "Denver site"
        },
        {
            "lat": 33.4484,
            "lon": -112.074,
            "label": "Phoenix site"
        }
    ],
    "radiusMiles": 5,
    "includeSubstations": true,
    "includePowerPlants": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("malonestar/hifld-grid-proximity-screener").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 = {
    "assets": [
        {
            "lat": 39.7392,
            "lon": -104.9903,
            "label": "Denver site",
        },
        {
            "lat": 33.4484,
            "lon": -112.074,
            "label": "Phoenix site",
        },
    ],
    "radiusMiles": 5,
    "includeSubstations": True,
    "includePowerPlants": True,
}

# Run the Actor and wait for it to finish
run = client.actor("malonestar/hifld-grid-proximity-screener").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 '{
  "assets": [
    {
      "lat": 39.7392,
      "lon": -104.9903,
      "label": "Denver site"
    },
    {
      "lat": 33.4484,
      "lon": -112.074,
      "label": "Phoenix site"
    }
  ],
  "radiusMiles": 5,
  "includeSubstations": true,
  "includePowerPlants": true
}' |
apify call malonestar/hifld-grid-proximity-screener --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=malonestar/hifld-grid-proximity-screener",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Power Grid Proximity Screener - Transmission Lines Near Sites",
        "description": "Electric substation proximity API: for each site (lat/lon), get distance to the nearest substation, transmission line (kV, owner), and power plant, plus density counts and a HIGH/MEDIUM/LOW grid-access tier. Keyless HIFLD data. For data-center, renewable and BESS siting.",
        "version": "1.0",
        "x-build-id": "fJ4xZrTI2v7iNipl6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/malonestar~hifld-grid-proximity-screener/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-malonestar-hifld-grid-proximity-screener",
                "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/malonestar~hifld-grid-proximity-screener/runs": {
            "post": {
                "operationId": "runs-sync-malonestar-hifld-grid-proximity-screener",
                "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/malonestar~hifld-grid-proximity-screener/run-sync": {
            "post": {
                "operationId": "run-sync-malonestar-hifld-grid-proximity-screener",
                "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": {
                    "assets": {
                        "title": "Assets (sites to screen)",
                        "type": "array",
                        "description": "Sites to screen for grid access. Each entry is an object { \"lat\": number, \"lon\": number, \"label\": \"optional name\" }. Also accepts \"lat,lon\" strings or [lat, lon] arrays. One dataset row (one billed result) is produced per asset; a bad entry yields an ERROR row and the run continues."
                    },
                    "radiusMiles": {
                        "title": "Search radius (miles)",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Radius around each asset to search for transmission lines, substations and power plants, in miles (1-50). Features beyond this distance are ignored. Default 5.",
                        "default": 5
                    },
                    "minVoltageKv": {
                        "title": "Minimum line voltage (kV)",
                        "minimum": 1,
                        "maximum": 1200,
                        "type": "integer",
                        "description": "Optional. Only count/consider transmission lines with voltage at or above this many kV (e.g. 115 or 230). Lines with unknown voltage are excluded when set. Does not filter substations or power plants. Leave empty to include all lines."
                    },
                    "includeSubstations": {
                        "title": "Screen electric substations",
                        "type": "boolean",
                        "description": "Also query the HIFLD Electric Substations layer and report the nearest substation (name, distance in km, max voltage) plus substations within the radius. On by default since v1.1 — set to false to skip substation screening and speed up large batches.",
                        "default": true
                    },
                    "includePowerPlants": {
                        "title": "Screen power plants",
                        "type": "boolean",
                        "description": "Also query the HIFLD Power Plants layer and report the nearest power plant (name, distance in km, fuel/type, capacity MW) plus power plants within the radius. On by default since v1.1 — set to false to skip power-plant screening and speed up large batches.",
                        "default": true
                    },
                    "includePlanned": {
                        "title": "Flag non-authoritative planned lines (advanced)",
                        "type": "boolean",
                        "description": "Advanced/opt-in. Also check a HIFLD 'planned transmission line' scratch layer that carries NO owner/voltage/status metadata. It is NOT an authoritative planned-line dataset — the planned_line_nearby flag is a low-confidence 'a planned-line geometry exists nearby' hint only. Default false.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max assets to screen",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of assets processed in one run (1-2000). One result row is emitted (and billed) per asset. Default 500.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```