# FHWA National Bridge Inventory Scraper (`automation-lab/fhwa-national-bridge-inventory-scraper`) Actor

Extract FHWA InfoBridge / National Bridge Inventory bridge records by state, owner, condition, or exact bridge ID.

- **URL**: https://apify.com/automation-lab/fhwa-national-bridge-inventory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.04 / 1,000 bridge record extracteds

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

## FHWA National Bridge Inventory Scraper

Extract bridge records from the public FHWA InfoBridge / National Bridge Inventory map data endpoints.

### What does this FHWA National Bridge Inventory Scraper do?

The FHWA National Bridge Inventory Scraper turns public InfoBridge bridge records into a clean Apify dataset.

It can scan bridges by state code or retrieve exact InfoBridge bridge IDs.

The actor is designed for infrastructure, civil engineering, insurance, and GIS workflows.

It uses HTTP requests against FHWA public endpoints and does not require login.

### Who is it for?

- 🏗️ Civil engineering firms monitoring bridge assets.
- 🗺️ GIS teams enriching public infrastructure layers.
- 🏛️ Government vendors researching bridge owners and agencies.
- 🛡️ Insurance and infrastructure risk teams screening bridge age and condition.
- 📊 Data teams building recurring National Bridge Inventory extracts.

### Why use it?

InfoBridge is powerful, but repeatable extraction from map workflows can be slow.

This actor gives you structured records with reproducible source URLs.

You can schedule it, call it through the API, and export JSON, CSV, Excel, or Parquet from Apify.

### Data source

The actor uses FHWA LTBP InfoBridge.

InfoBridge is a public national repository for bridge performance and National Bridge Inventory data.

The actor currently uses the public map and bridge data endpoints visible from InfoBridge.

### Data fields

| Field | Description |
| --- | --- |
| `bridgeId` | InfoBridge `NEW_BRIDGE_ID` |
| `bridgeYearlyId` | InfoBridge yearly bridge record ID |
| `structureNumber` | NBI structure number |
| `stateCode` | Numeric FHWA/NBI state code |
| `stateName` | State name |
| `ownerAgency` | Owning agency text |
| `yearBuilt` | Construction year |
| `structureLength` | Structure length from InfoBridge |
| `mainSpanMaterials` | Main span material code and label |
| `mainSpanDesign` | Main span design code and label |
| `bridgeCondition` | G/F/P condition code when requested |
| `conditionLabel` | Good, Fair, or Poor label |
| `detailUrl` | Public InfoBridge detail page |
| `sourceUrl` | Public JSON endpoint used by the actor |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape FHWA National Bridge Inventory data?

This actor uses pay-per-event pricing.

You pay a small start fee and then a per-record fee for each saved bridge item.

The default input is intentionally small enough to make the first run inexpensive.

### Input overview

The most common input is a state code and a maximum number of bridge records.

You can also pass exact InfoBridge bridge IDs when you already know the assets to monitor.

### Input fields

- `stateCodes` — numeric FHWA/NBI state codes, such as `1` for Alabama or `48` for Texas.
- `bridgeIds` — exact InfoBridge `NEW_BRIDGE_ID` values.
- `maxItems` — maximum number of records to save.
- `bridgeCondition` — optional Good/Fair/Poor filter.
- `ownerContains` — optional owner agency text filter.
- `includeCondition` — fetch condition code for emitted records.
- `requestDelayMs` — polite request delay for InfoBridge.

### Example input: first 100 Alabama bridges

```json
{
  "stateCodes": [1],
  "maxItems": 100,
  "includeCondition": true,
  "requestDelayMs": 120
}
````

### Example input: poor-condition bridges

```json
{
  "stateCodes": [1],
  "maxItems": 250,
  "bridgeCondition": "Poor",
  "includeCondition": true
}
```

### Example input: exact bridge IDs

```json
{
  "bridgeIds": [1, 2, 1000],
  "maxItems": 3,
  "includeCondition": true
}
```

### Example output

```json
{
  "bridgeId": 1,
  "bridgeYearlyId": 26002063,
  "structureNumber": "DAPAMCRED0VBC77",
  "stateCode": 1,
  "stateName": "Alabama",
  "ownerAgency": "74-Army",
  "yearBuilt": 1975,
  "structureLength": 23.3,
  "mainSpanMaterials": "3-Steel",
  "mainSpanDesign": "19-Culvert",
  "bridgeCondition": "P",
  "conditionLabel": "Poor",
  "detailUrl": "https://infobridge.fhwa.dot.gov/Data/BridgeDetail/26002063",
  "sourceUrl": "https://infobridge.fhwa.dot.gov/Data/GetMapBridgeData?BridgeID=1",
  "scrapedAt": "2026-07-06T00:00:00.000Z"
}
```

### How to run it

1. Open the actor on Apify.
2. Choose state codes or exact bridge IDs.
3. Set `maxItems` to the number of records you need.
4. Optionally filter by condition or owner agency.
5. Run the actor.
6. Download the dataset in your preferred format.

### State code tips

The input uses numeric FHWA/NBI state codes.

Examples include Alabama `1`, California `6`, Florida `12`, New York `36`, and Texas `48`.

Use exact `bridgeIds` when you need deterministic repeat monitoring of known bridges.

### Condition filter tips

The actor maps InfoBridge condition codes to human-readable labels.

- `G` means Good.
- `F` means Fair.
- `P` means Poor.

Use `bridgeCondition` when you only need one condition class.

### Owner filter tips

`ownerContains` is a case-insensitive substring filter.

Examples include `County Highway Agency`, `State Highway Agency`, or `Army`.

The filter is applied after a bridge record is fetched.

### Integrations

Use the actor with Apify datasets, webhooks, schedules, and API clients.

Common workflows include:

- Scheduled bridge-condition monitoring.
- GIS layer enrichment.
- Infrastructure sales lead lists by owner agency.
- Insurance risk screening by bridge age and condition.
- Data warehouse imports for public-sector analytics.

### API usage: Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fhwa-national-bridge-inventory-scraper').call({
  stateCodes: [1],
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

### API usage: Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/fhwa-national-bridge-inventory-scraper').call({
    'stateCodes': [1],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage: cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~fhwa-national-bridge-inventory-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"stateCodes":[1],"maxItems":100}'
```

### MCP usage

Connect through Apify MCP to use this actor from AI tools such as Claude Desktop, Claude Code, and other MCP-compatible clients.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/fhwa-national-bridge-inventory-scraper
```

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/fhwa-national-bridge-inventory-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/fhwa-national-bridge-inventory-scraper"
    }
  }
}
```

Example prompts:

- "Get 100 Alabama bridge records from FHWA InfoBridge."
- "Find poor-condition bridge records for state code 1."
- "Export records for these exact InfoBridge bridge IDs."

### Performance and politeness

The actor uses conservative HTTP requests.

InfoBridge exposes rate-limit headers, so the actor includes a request delay setting.

Avoid unnecessarily large runs when a small state or exact bridge list will answer your question.

### Current limitations

The lightweight public map endpoint does not expose every NBI field.

The MVP focuses on identity, owner, construction, span, condition, and detail links.

County-level filtering is not included in the current output because it would require a heavier endpoint workflow.

### FAQ

#### Why did my run return no results?

Check that the state code is valid and `maxItems` is greater than zero.

If you pass exact bridge IDs, confirm they are InfoBridge `NEW_BRIDGE_ID` values.

#### Why is my run slow?

Lower `maxItems` or use exact `bridgeIds`.

You can also reduce `requestDelayMs`, but keep it polite for FHWA public infrastructure.

#### Can it scrape county-level bridge fields?

Not in this first version. The lightweight public map endpoint does not expose county fields, so this actor prioritizes reliable state and exact-ID extraction.

### Legality

This actor collects data from a public US government information system.

Use the results responsibly and follow Apify terms and applicable laws.

Do not overload the source website.

### Related scrapers

Explore other public-data and government-data actors from Automation Lab:

- https://apify.com/automation-lab

### Changelog

- Initial version: state and exact-ID bridge extraction from FHWA InfoBridge public endpoints.

### Support

If you need additional fields such as county, route, or historical condition rows, open an issue on the actor page.

### Notes for analysts

The actor includes both `detailUrl` and `sourceUrl` to make records auditable.

Use those fields when joining outputs with internal GIS or asset-management systems.

# Actor input Schema

## `stateCodes` (type: `array`):

Numeric state codes to scan. Examples: 1 Alabama, 6 California, 12 Florida, 36 New York, 48 Texas. Ignored when bridgeIds are provided.

## `bridgeIds` (type: `array`):

Optional NEW\_BRIDGE\_ID values from InfoBridge. Use this for precise repeat monitoring.

## `maxItems` (type: `integer`):

Maximum records to save to the dataset.

## `bridgeCondition` (type: `string`):

Optional FHWA bridge condition filter. Leave empty for all conditions.

## `ownerContains` (type: `string`):

Case-insensitive substring filter for owner agency, e.g. County Highway Agency or State Highway Agency.

## `includeCondition` (type: `boolean`):

Fetch bridge condition from the InfoBridge map data endpoint for each emitted record.

## `requestDelayMs` (type: `integer`):

Small delay between requests to respect InfoBridge rate-limit headers.

## Actor input object example

```json
{
  "stateCodes": [
    1
  ],
  "bridgeIds": [],
  "maxItems": 20,
  "bridgeCondition": "",
  "includeCondition": true,
  "requestDelayMs": 120
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "stateCodes": [
        1
    ],
    "bridgeIds": [],
    "maxItems": 20,
    "bridgeCondition": "",
    "ownerContains": "",
    "includeCondition": true,
    "requestDelayMs": 120
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fhwa-national-bridge-inventory-scraper").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 = {
    "stateCodes": [1],
    "bridgeIds": [],
    "maxItems": 20,
    "bridgeCondition": "",
    "ownerContains": "",
    "includeCondition": True,
    "requestDelayMs": 120,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fhwa-national-bridge-inventory-scraper").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 '{
  "stateCodes": [
    1
  ],
  "bridgeIds": [],
  "maxItems": 20,
  "bridgeCondition": "",
  "ownerContains": "",
  "includeCondition": true,
  "requestDelayMs": 120
}' |
apify call automation-lab/fhwa-national-bridge-inventory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/fhwa-national-bridge-inventory-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FHWA National Bridge Inventory Scraper",
        "description": "Extract FHWA InfoBridge / National Bridge Inventory bridge records by state, owner, condition, or exact bridge ID.",
        "version": "0.1",
        "x-build-id": "9JKDRjyZBl3kKknrx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fhwa-national-bridge-inventory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fhwa-national-bridge-inventory-scraper",
                "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/automation-lab~fhwa-national-bridge-inventory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fhwa-national-bridge-inventory-scraper",
                "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/automation-lab~fhwa-national-bridge-inventory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fhwa-national-bridge-inventory-scraper",
                "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": [
                    "maxItems"
                ],
                "properties": {
                    "stateCodes": {
                        "title": "State FIPS / NBI codes",
                        "type": "array",
                        "description": "Numeric state codes to scan. Examples: 1 Alabama, 6 California, 12 Florida, 36 New York, 48 Texas. Ignored when bridgeIds are provided.",
                        "items": {
                            "type": "integer",
                            "minimum": 1,
                            "maximum": 78
                        },
                        "default": [
                            1
                        ]
                    },
                    "bridgeIds": {
                        "title": "Exact InfoBridge bridge IDs",
                        "type": "array",
                        "description": "Optional NEW_BRIDGE_ID values from InfoBridge. Use this for precise repeat monitoring.",
                        "items": {
                            "type": "integer",
                            "minimum": 1
                        }
                    },
                    "maxItems": {
                        "title": "Maximum bridge records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum records to save to the dataset.",
                        "default": 20
                    },
                    "bridgeCondition": {
                        "title": "Bridge condition",
                        "enum": [
                            "",
                            "Good",
                            "Fair",
                            "Poor",
                            "G",
                            "F",
                            "P"
                        ],
                        "type": "string",
                        "description": "Optional FHWA bridge condition filter. Leave empty for all conditions.",
                        "default": ""
                    },
                    "ownerContains": {
                        "title": "Owner agency contains",
                        "type": "string",
                        "description": "Case-insensitive substring filter for owner agency, e.g. County Highway Agency or State Highway Agency."
                    },
                    "includeCondition": {
                        "title": "Include condition code",
                        "type": "boolean",
                        "description": "Fetch bridge condition from the InfoBridge map data endpoint for each emitted record.",
                        "default": true
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Small delay between requests to respect InfoBridge rate-limit headers.",
                        "default": 120
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```