# FHWA National Bridge Inventory — US Bridge Conditions (`compute-edge/fhwa-nbi-bridges-scraper`) Actor

Extract FHWA National Bridge Inventory data. 600K+ US bridges with location, condition ratings, traffic, year built, structure type, owner, and inspection history. For civil engineering, infrastructure asset management, real estate diligence, and insurance underwriting.

- **URL**: https://apify.com/compute-edge/fhwa-nbi-bridges-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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

## FHWA National Bridge Inventory Scraper

### Overview

Extract comprehensive infrastructure data from the **Federal Highway Administration (FHWA) National Bridge Inventory (NBI)** database. This actor downloads official NBI records for all 50 US states, providing engineering specifications, structural ratings, inspection data, and maintenance information for 600,000+ bridges across the nation.

The NBI is the authoritative source for bridge condition assessments used by the U.S. Department of Transportation, state DOTs, and infrastructure investors to prioritize bridge repairs and funding allocation under the $1.2 trillion Infrastructure Investment and Jobs Act.

### Key Features

- **Nationwide Coverage**: Access bridge data for all 50 US states (2022-2024 datasets)
- **116 Data Fields**: Comprehensive technical specifications including structural ratings, inspection dates, material composition, and maintenance costs
- **Condition Filtering**: Filter by bridge condition rating (Good/Fair/Poor) — critical signals for infrastructure prioritization
- **Flexible Queries**: Filter by year built, average daily traffic (ADT), ownership, and geographic features
- **Clean Output**: Pre-parsed decimal coordinates (lat/lon), condition ratings, and computed bridge age
- **High Performance**: Downloads entire state files (~6-7MB) in seconds; batch processes 600K records efficiently

### Who Should Use This Actor

#### Civil Engineering & Infrastructure
- **Asset managers**: Track bridge conditions across portfolios; identify maintenance backlogs
- **Design firms**: Research historical construction data, compare structural approaches
- **DOT agencies**: Analyze regional bridge health, plan capital improvement programs

#### Real Estate & Investment
- **Due diligence analysts**: Assess bridge access/condition for commercial property valuation
- **Infrastructure funds**: Identify deteriorating bridges eligible for $1.2T federal funding
- **Transportation planners**: Model traffic patterns and corridor prioritization

#### Risk & Insurance
- **Underwriters**: Score catastrophic structure risk (scour-critical bridges, aging materials)
- **Claims adjusters**: Investigate bridge-related incidents using official condition ratings
- **Consultants**: Model failure likelihood based on deck/substructure ratings

#### Public Data & Research
- **Civic engagement**: Monitor bridge conditions in your community
- **Academic researchers**: Analyze infrastructure aging patterns, maintenance cost trends
- **Transparency advocates**: Track government infrastructure assessments

---

### Data Fields

The actor outputs 50+ structured fields per bridge:

| Field | Description | Example |
|-------|-------------|---------|
| **state** | 2-letter state code | `VT` |
| **structureNumber** | Unique bridge identifier (NBI format) | `000053591-00002` |
| **latitude** / **longitude** | Decimal coordinates | `45.60, -71.88` |
| **featuresIntersected** | What the bridge crosses (river, road, etc.) | `NORTH BRANCH RIVER` |
| **facilityCarried** | Road/highway name on bridge | `FOUR MILE ROAD` |
| **yearBuilt** | Year of original construction | `2003` |
| **bridgeAge** | Age in years (computed) | `21` |
| **bridgeCondition** | Overall condition rating | `Good`, `Fair`, `Poor` |
| **structureLengthM** | Bridge length in meters | `16.8` |
| **deckWidthM** | Deck width in meters | `4.9` |
| **deckArea** | Deck surface area (m²) | `82.32` |
| **adt** | Average daily traffic volume | `10`, `1500`, `45000` |
| **deckCondition** | Deck condition rating (0-9 or N) | `6` |
| **superstructureCondition** | Above-deck condition (0-9 or N) | `7` |
| **substructureCondition** | Below-deck condition (0-9 or N) | `7` |
| **owner** | Owner code (01=State, 02=County, 03=City, etc.) | `63` |
| **ownerDescription** | Owner type (decoded) | `Bureau of Fish and Wildlife` |
| **dateOfInspection** | Last inspection date | `2023-08-01` |
| **inspectFreqMonths** | Inspection cycle in months | `24` |
| **scourCritical** | Is bridge vulnerable to water scour? | `true`, `false` |
| **functionalClass** | Functional classification (0=Rural local to 9=Interstate) | `09` |
| **bridgeImpCost** / **totalImpCost** | Estimated improvement costs (USD) | `150000` |

Plus 25+ additional structural and operational fields (material type, span configuration, load ratings, etc.).

---

### How to Scrape Bridge Data

#### Tutorial 1: Find All Bridges in Poor Condition Built Before 1950

1. **Open the Apify Console** and launch this actor
2. **Input Configuration**:
   - **States**: `["NY", "MA", "CT"]` (or customize to your region)
   - **Year**: `2024`
   - **Bridge Condition**: `Poor`
   - **Minimum Year Built**: Leave blank (no filter)
   - **Maximum Year Built**: `1950`
   - **Max Results**: `5000`
3. **Run** the actor (typically 30-90 seconds for 3 states)
4. **Export** the results as CSV or JSON from the dataset view
5. **Analyze**: Sort by `bridgeAge` to prioritize oldest structures; check `totalImpCost` for funding gaps

**Use case**: Identify aging bridges in critical condition eligible for federal infrastructure grants.

#### Tutorial 2: Compare High-Traffic Bridges Across States

1. **Input Configuration**:
   - **States**: `["CA", "TX", "FL"]` (high-traffic states)
   - **Year**: `2024`
   - **Bridge Condition**: `all`
   - **Minimum ADT**: `10000` (major corridors only)
   - **Max Results**: `2000`
2. **Run** and export results
3. **In your spreadsheet**: Group by `state`, sort by `adt` descending, analyze `bridgeCondition` distribution
4. **Insight**: Identify states with aging high-traffic bridges that need near-term investment

**Use case**: Transportation planning; corridor prioritization; comparative infrastructure analysis.

#### Tutorial 3: Assess Bridge Risk for Real Estate Due Diligence

1. **Input Configuration**:
   - **States**: `["WA"]` (or target state)
   - **Bridge Condition**: `Poor`
   - **Max Results**: `500`
2. **Run** and download dataset as JSON
3. **Cross-reference** with property addresses:
   - Filter bridges by `latitude`/`longitude` proximity (import into GIS)
   - Check `dateOfInspection` (recent = more reliable condition data)
   - Review `scourCritical` flag (water-related closure risk)
4. **Report**: Include bridge condition in property risk assessment

**Use case**: Due diligence for commercial real estate; environmental risk scoring; infrastructure risk underwriting.

---

### Input Configuration

#### Required
- **states** (array of strings) — 2-letter state postal codes
  - Examples: `["VT"]`, `["CA", "NY", "TX"]`, `["MA", "CT", "RI", "NH"]`
  - Accepts all 50 US states

#### Optional Filters
- **year** (enum: 2022, 2023, 2024) — NBI data year (default: 2024)
- **bridgeCondition** (enum: "all", "Good", "Fair", "Poor") — Overall condition filter (default: "all")
- **minYearBuilt** (integer) — Include only bridges built in or after this year
- **maxYearBuilt** (integer) — Include only bridges built in or before this year
- **minADT** (integer) — Minimum average daily traffic (useful for filtering major corridors)
- **ownerCode** (string) — Filter by owner type:
  - `01` = State Highway Agency
  - `02` = County Highway Agency
  - `03` = City/Town Highway Agency
  - `11` = State Park/Forest Agency
  - `62` = Indian Tribal Government
  - `63` = Bureau of Fish and Wildlife
  - See full list in data fields section
- **featuresDesc** (string) — Partial match on what the bridge crosses
  - Examples: "RIVER", "I-89", "MISSISSIPPI", "LAKE"
- **maxResults** (integer, 0-50000) — Maximum records to return (0 = unlimited, default: 1000)

#### Example Configurations

**All Vermont bridges, 2024:**
```json
{
  "states": ["VT"],
  "year": "2024",
  "bridgeCondition": "all",
  "maxResults": 0
}
````

**Aged high-traffic bridges in California:**

```json
{
  "states": ["CA"],
  "year": "2024",
  "maxYearBuilt": 1980,
  "minADT": 5000,
  "bridgeCondition": "Fair",
  "maxResults": 10000
}
```

**Bridges crossing water bodies in Northeast:**

```json
{
  "states": ["MA", "CT", "NY", "VT"],
  "year": "2024",
  "featuresDesc": "RIVER",
  "maxResults": 5000
}
```

***

### Pricing

- **Cost per bridge**: $0.004/result (based on compute time + data transfer)
- **Typical run**: 50 bridges = $0.20; 1,000 bridges = $4.00
- **Full state download** (e.g., California): ~2,500 bridges = $10.00
- **Apify compute units**: ~0.01-0.02 CU per 100 records (pricing depends on Apify plan)

***

### Data Quality & Accuracy

- **Source**: Official FHWA National Bridge Inventory (published annually)
- **Coverage**: 600,000+ bridges; all US states, territories, and tribes
- **Refresh**: Data updates annually (typically March-April for prior year)
- **Condition ratings**: Rated 0-9 scale (0=worst, 9=best); "N" = not applicable
- **Missing data**: Some rural/private bridges have incomplete inspection records; represented as `null`
- **Coordinates**: Converted from FHWA DDDMMSS format to decimal degrees for mapping

***

### Other Actors

**Explore related infrastructure data:**

- **EPA ECHO Scraper** — Environmental Compliance & Historic Emissions (permits, violations, facility data)
- **USGS Earthquake Scraper** — Seismic hazard zones (for bridge seismic risk assessment)
- **HUD Fair Market Rents** — Real estate valuation context
- **Treasury CAFR Scraper** — State/local government financial reports (budget context for bridge funding)

***

### FAQ

#### Q: Can I download all 600K+ bridges at once?

**A:** Yes. Set `maxResults: 0` and `states: ["AL", "AK", ..., "WY"]` (all 50 states). Expect ~20-30 minutes runtime and ~150-200 MB dataset. Costs approximately $40-60 depending on result count.

#### Q: What is "scourCritical"?

**A:** Bridges where water flow can undermine foundations, especially during floods. Essential for transportation safety planning. If `scourCritical: true`, the bridge may be vulnerable to sudden closure.

#### Q: Why are some fields null?

**A:** The NBI survey allows "not applicable" (N) or missing data. Older bridges may lack detailed inspection records. Rural/private bridges often have sparse data. `null` fields won't break your analysis—they simply represent absence of data.

#### Q: How do I use coordinates for mapping?

**A:** Import `latitude`, `longitude` into Google Maps, Mapbox, ArcGIS, or any GIS tool. Decimal degree format works natively in most mapping APIs.

#### Q: Can I filter by specific highway (e.g., "I-95")?

**A:** Use the `featuresDesc` filter with partial matching (e.g., "I-95"). Note: Not all bridges store standardized route designations; some show descriptive names instead.

#### Q: What's the difference between "condition" fields (deckCondition, superstructure, etc.)?

**A:** The FHWA rates three components independently:

- **Deck**: Wearing surface and immediate support
- **Superstructure**: Above the supports (beams, trusses, arches)
- **Substructure**: Piers, abutments, and foundations
- **bridgeCondition**: Composite rating (Good/Fair/Poor) derived from the worst component

#### Q: How often is the data updated?

**A:** The NBI publishes updated data annually (typically March-April). This actor always fetches the latest version available on FHWA's servers. Check back each spring for current-year data.

#### Q: Is this legal to use for commercial purposes?

**A:** Yes. The FHWA NBI is public government data. Use it freely for analysis, reporting, and commercial applications. Include a citation: "Data source: Federal Highway Administration National Bridge Inventory."

***

### Legal Disclaimer

This actor extracts publicly available data from the FHWA National Bridge Inventory. Data is provided for informational purposes. The actor maintainers and Apify are not liable for:

- Decisions made based on this data
- Accuracy or timeliness of underlying FHWA data
- Commercial impacts from data use

Always verify critical findings against official FHWA sources and consult with qualified engineers for structural decisions.

***

### Support & Contact

For issues, feature requests, or questions:

- **GitHub Issues** (if available)
- **Apify Forum**: Post in the Apify community forum
- **Contact**: seatsignal@apify.actor

***

*Last updated: May 2026*

# Actor input Schema

## `states` (type: `array`):

2-letter state postal codes (e.g., \['CA', 'NY', 'TX']). Required, at least one state.

## `year` (type: `string`):

NBI data year. Available: 2022, 2023, 2024.

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

Filter by bridge condition rating (Good/Fair/Poor) or 'all' for no filter.

## `minYearBuilt` (type: `integer`):

Only include bridges built in or after this year. Leave blank to disable filter.

## `maxYearBuilt` (type: `integer`):

Only include bridges built in or before this year. Leave blank to disable filter.

## `minADT` (type: `integer`):

Only include bridges with ADT >= this value. Leave blank to disable filter.

## `ownerCode` (type: `string`):

Filter by owner code (e.g., '01'=State Highway Agency, '02'=County, '03'=City/Town). Leave blank to disable filter.

## `featuresDesc` (type: `string`):

Case-insensitive partial match on what the bridge crosses (e.g., 'RIVER', 'I-89'). Leave blank to disable filter.

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

Maximum number of bridge records to return. Set to 0 for unlimited.

## Actor input object example

```json
{
  "states": [
    "VT"
  ],
  "year": "2024",
  "bridgeCondition": "all",
  "ownerCode": "",
  "featuresDesc": "",
  "maxResults": 1000
}
```

# Actor output Schema

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

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/fhwa-nbi-bridges-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/fhwa-nbi-bridges-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 '{}' |
apify call compute-edge/fhwa-nbi-bridges-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=compute-edge/fhwa-nbi-bridges-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FHWA National Bridge Inventory — US Bridge Conditions",
        "description": "Extract FHWA National Bridge Inventory data. 600K+ US bridges with location, condition ratings, traffic, year built, structure type, owner, and inspection history. For civil engineering, infrastructure asset management, real estate diligence, and insurance underwriting.",
        "version": "0.1",
        "x-build-id": "QpkcJXjg2PY1GgSSD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~fhwa-nbi-bridges-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-fhwa-nbi-bridges-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/compute-edge~fhwa-nbi-bridges-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-fhwa-nbi-bridges-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/compute-edge~fhwa-nbi-bridges-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-fhwa-nbi-bridges-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": [
                    "states"
                ],
                "properties": {
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "2-letter state postal codes (e.g., ['CA', 'NY', 'TX']). Required, at least one state.",
                        "default": [
                            "VT"
                        ]
                    },
                    "year": {
                        "title": "Year",
                        "enum": [
                            "2022",
                            "2023",
                            "2024"
                        ],
                        "type": "string",
                        "description": "NBI data year. Available: 2022, 2023, 2024.",
                        "default": "2024"
                    },
                    "bridgeCondition": {
                        "title": "Bridge Condition Filter",
                        "enum": [
                            "all",
                            "Good",
                            "Fair",
                            "Poor"
                        ],
                        "type": "string",
                        "description": "Filter by bridge condition rating (Good/Fair/Poor) or 'all' for no filter.",
                        "default": "all"
                    },
                    "minYearBuilt": {
                        "title": "Minimum Year Built",
                        "type": "integer",
                        "description": "Only include bridges built in or after this year. Leave blank to disable filter."
                    },
                    "maxYearBuilt": {
                        "title": "Maximum Year Built",
                        "type": "integer",
                        "description": "Only include bridges built in or before this year. Leave blank to disable filter."
                    },
                    "minADT": {
                        "title": "Minimum Average Daily Traffic (ADT)",
                        "type": "integer",
                        "description": "Only include bridges with ADT >= this value. Leave blank to disable filter."
                    },
                    "ownerCode": {
                        "title": "Owner Code",
                        "type": "string",
                        "description": "Filter by owner code (e.g., '01'=State Highway Agency, '02'=County, '03'=City/Town). Leave blank to disable filter.",
                        "default": ""
                    },
                    "featuresDesc": {
                        "title": "Features Description Filter",
                        "type": "string",
                        "description": "Case-insensitive partial match on what the bridge crosses (e.g., 'RIVER', 'I-89'). Leave blank to disable filter.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of bridge records to return. Set to 0 for unlimited.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
