# US Transportation Data API (`lentic_clockss/us-transportation-search`) Actor

Search 21 US transportation data sources — traffic crashes, vehicle inspections, MTA ridership, highway infrastructure, fuel tax, driver registrations, and EV data. Returns normalized results from USDOT, NHTSA, NY DMV, Chicago DOT, and state agencies via SIP Public Data Gateway.

- **URL**: https://apify.com/lentic\_clockss/us-transportation-search.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## US Transportation & Traffic Data Search

Apify Actor that queries the **SIP Public Data Gateway** over HTTPS — **no browser, no scraping**. Provide search terms (location names, route identifiers, or keywords); the Actor queries up to 21 US transportation data products in parallel and returns normalized rows enriched with source metadata.

### Features

- **One search, 21 sources** — Query crash reports, transit ridership, highway data, and vehicle registrations across Chicago, NYC, NJ, NY, and WA with a single keyword
- **Official government data** — All 21 products are sourced from public US federal and city/state transportation databases
- **Structured JSON output** — Every record includes `_product_id`, `_source`, `_search_term`, and `_collected_at` metadata for traceability
- **Category toggles** — Enable or disable four source categories (vehicle safety, traffic data, infrastructure, registrations) per run
- **No upstream API keys needed** — SIP handles authentication with all upstream transportation APIs
- **Pure HTTP client** — No browser overhead; uses `httpx` for fast, parallel requests

### Example Output

```json
[
  {
    "crash_date": "2024-06-12",
    "borough": "BROOKLYN",
    "on_street_name": "ATLANTIC AVENUE",
    "number_of_persons_injured": 2,
    "number_of_persons_killed": 0,
    "contributing_factor_vehicle_1": "Failure to Yield Right-of-Way",
    "vehicle_type_code1": "Taxi",
    "latitude": "40.6863",
    "longitude": "-73.9778",
    "_product_id": "us_transport_nyc_collisions",
    "_source": "nyc_collisions",
    "_search_term": "Brooklyn",
    "_collected_at": "2026-04-13T10:00:00Z"
  },
  {
    "station": "GRAND CENTRAL-42 ST",
    "line": "4 5 6",
    "ridership": 38754,
    "service_date": "2024-03-11",
    "_product_id": "us_transport_ny_mta_subway",
    "_source": "ny_mta_subway",
    "_search_term": "Grand Central",
    "_collected_at": "2026-04-13T10:00:00Z"
  }
]
````

### What it does

- Searches across **21 active US transportation data products** grouped into four toggleable categories: vehicle safety, traffic & transit, infrastructure, and registrations.
- All enabled product queries for a given search term execute **concurrently** via `asyncio.gather`, minimizing total run time.
- Each result row is enriched with `_product_id`, `_source`, `_search_term`, and `_collected_at` so you can trace every record back to its origin.
- Pure HTTP client (`httpx`) — no Playwright, no browser overhead.

### Data sources

| Category | SIP Product ID | Agency / Source |
|----------|---------------|----------------|
| **Vehicle Safety** | `us_transport_chicago_crashes` | Chicago DOT — crash reports |
| | `us_transport_chicago_crash_vehicles` | Chicago DOT — vehicles involved in crashes |
| | `us_transport_nyc_collisions` | NYC Open Data / NYPD — motor vehicle collisions |
| | `us_transport_nj_inspections` | NJ MVC — vehicle inspection records |
| **Traffic & Transit** | `us_transport_ny_aadt` | NYSDOT — Annual Average Daily Traffic counts |
| | `us_transport_ny_mta_bridge_tunnel` | MTA — bridge and tunnel traffic volumes |
| | `us_transport_ny_mta_subway` | MTA — subway ridership by station |
| | `us_transport_ny_ezpass` | NY Thruway / MTA — E-ZPass usage data |
| | `us_transport_ny_ticket_convictions` | NY DMV — traffic ticket conviction records |
| | `us_transport_ny_traffic_tickets` | NY DMV — traffic tickets issued |
| **Infrastructure** | `us_transport_fuel_tax` | FHWA — state motor fuel tax data |
| | `us_transport_highway_funding` | FHWA — federal highway funding apportionments |
| | `us_transport_hpms_county` | FHWA HPMS — county-level road condition data |
| | `us_transport_road_mileage` | FHWA — national public road mileage by type |
| | `us_transport_usdot_transit_uza` | USDOT NTD — transit statistics by urbanized area |
| **Registrations** | `us_transport_licensed_drivers` | FHWA — licensed drivers by state/age |
| | `us_transport_ny_driver_licenses` | NY DMV — driver license records |
| | `us_transport_ny_dmv_facilities` | NY DMV — office locations and hours |
| | `us_transport_ny_vehicle_reg` | NY DMV — registered vehicle data |
| | `us_transport_wa_ev_reg` | WA DOL — electric vehicle registrations |
| | `us_transport_ny_highway_mileage` | NYSDOT — highway mileage by route type |

### Use cases

**Fleet management & logistics** — Query crash hotspots, AADT counts along delivery corridors, and toll/E-ZPass usage to optimize routing and assess infrastructure risk on specific road segments.

**Insurance analytics** — Pull NYC collision data, NJ inspection results, and NY traffic ticket convictions to enrich underwriting models with location- and vehicle-level safety signals.

**Urban planning & research** — Combine MTA subway ridership, bridge/tunnel volumes, and HPMS road data to analyze mobility patterns, identify capacity constraints, and model transit demand.

**EV & sustainability analysis** — Cross-reference Washington State EV registration growth against national fuel tax collections and highway funding data to track electrification trends and infrastructure investment.

**Safety research** — Join Chicago crash reports with NYC collision records and NY ticket conviction data to compare enforcement and outcome patterns across jurisdictions.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchTerms` | `string[]` | — | **Required.** Keywords or location names (e.g. `["Manhattan", "I-95", "Brooklyn"]`). Each term is searched across all enabled categories. |
| `includeVehicleSafety` | `boolean` | `true` | Crash reports (Chicago + NYC), NJ vehicle inspections. |
| `includeTrafficData` | `boolean` | `true` | AADT, MTA ridership, E-ZPass, traffic tickets/convictions. |
| `includeInfrastructure` | `boolean` | `true` | Fuel tax, highway funding, HPMS road data, road mileage, transit UZA stats. |
| `includeRegistrations` | `boolean` | `false` | Licensed drivers, NY/WA vehicle & driver registrations, NY DMV locations. Off by default (high volume). |
| `maxResultsPerSource` | `integer` | `50` | Rows returned per SIP product per term. Max 200 (gateway cap). |
| `sipApiKey` | `string` | — | Local testing only. Use the `SIP_API_KEY` environment variable on Apify. |

#### Example input

```json
{
  "searchTerms": ["Manhattan", "Brooklyn"],
  "includeVehicleSafety": true,
  "includeTrafficData": true,
  "includeInfrastructure": true,
  "includeRegistrations": false,
  "maxResultsPerSource": 50
}
```

### Output (dataset items)

Each row is a raw SIP search hit with four Actor-added metadata fields:

| Field | Description |
|-------|-------------|
| `_product_id` | SIP product identifier (e.g. `us_transport_nyc_collisions`) |
| `_source` | Short label from the product map (e.g. `nyc_collisions`) |
| `_search_term` | The search term that produced this row |
| `_collected_at` | ISO 8601 UTC timestamp of when the row was collected |

Native fields vary by product. Common examples include `crash_date`, `borough`, `location`, `vehicle_type`, `injuries`, `road_name`, `aadt`, `station_id`, `ridership`, `registration_class`, `vin`.

#### Example record (NYC collisions)

```json
{
  "crash_date": "2024-03-15",
  "borough": "MANHATTAN",
  "on_street_name": "5 AVENUE",
  "number_of_persons_injured": 1,
  "number_of_persons_killed": 0,
  "contributing_factor_vehicle_1": "Driver Inattention/Distraction",
  "vehicle_type_code1": "Sedan",
  "latitude": "40.7549",
  "longitude": "-73.9840",
  "_product_id": "us_transport_nyc_collisions",
  "_source": "nyc_collisions",
  "_search_term": "Manhattan",
  "_collected_at": "2026-04-08T10:30:00Z"
}
```

#### Example record (MTA subway)

```json
{
  "station": "TIMES SQ-42 ST",
  "line": "1 2 3",
  "ridership": 42891,
  "service_date": "2024-01-08",
  "_product_id": "us_transport_ny_mta_subway",
  "_source": "ny_mta_subway",
  "_search_term": "Manhattan",
  "_collected_at": "2026-04-08T10:30:00Z"
}
```

### Configuration

Set the SIP gateway key as an Apify Actor **environment variable** (mark as secret):

| Variable | Description |
|----------|-------------|
| `SIP_API_KEY` | SIP `X-API-Key` value. Required. |
| `SIP_API_BASE` | Override gateway root (optional). Default: `https://opendata.best/api/v1/data`. |

**Never put the key in run input on production** — use environment variables so keys are not stored in run history.

### Pricing (reference)

Approximate positioning: **~$2 per 1,000 results** (combined platform + API cost). Set exact USD amounts in the Apify Actor **Pricing** tab. This README does not lock prices.

### Local development

```bash
cd "/Users/kane/Projects/Apify Actors/sip-us-transportation-search"
python3.13 -m venv .venv
.venv/bin/pip install -r requirements.txt
export SIP_API_KEY="your-key"
mkdir -p storage/key_value_stores/default
echo '{"searchTerms":["Manhattan"],"maxResultsPerSource":5}' > storage/key_value_stores/default/INPUT.json
apify run
```

Or run directly:

```bash
SIP_API_KEY=your-key python -m src
```

(with `INPUT.json` under `storage/key_value_stores/default/` per Apify CLI conventions).

### Deploy

```bash
apify login
apify push
```

Use `APIFY_TOKEN` or CLI login — never commit tokens to git.

### Legal

You must comply with SIP **terms of use**, Apify **terms of service**, and all applicable **data protection** and **privacy laws** (including CCPA for California driver data and any applicable DPPA restrictions on DMV records). This Actor is an API client to the SIP Public Data Gateway; you are responsible for the lawful use of all downstream government data. Driver and vehicle registration data may carry additional restrictions under the Driver's Privacy Protection Act (DPPA) — consult legal counsel before use in commercial applications.

### Use as MCP Tool (AI Agent Integration)

This Actor works as an MCP tool — AI agents (Claude, GPT, Cursor) can discover and run it automatically.

#### Quick setup (Claude Desktop / Cursor / VS Code)

Add to your MCP config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Then ask your AI: *"Search for Tesla recall in US transportation databases"*

#### Direct API call

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("lentic_clockss/us-transportation-search").call(
    run_input={"searchTerms": ["Tesla recall"], "maxResultsPerSource": 50}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Other Data API Actors

- [EU Energy & Education Data API](https://apify.com/lentic_clockss/eu-energy-education-search)
- [UK Government Data API](https://apify.com/lentic_clockss/uk-data-search)
- [Japan Government Data API](https://apify.com/lentic_clockss/japan-government-data-search)

***

### 🔗 Integrations

Connect this Actor to **1,000+ apps** with zero code changes:

| Platform | How to Connect |
|----------|---------------|
| **Make** | Search "Apify" in Make → select "Run Actor" → Actor ID: `lentic_clockss/us-transportation-search` |
| **n8n** | Add Apify node → "Run Actor" action → Actor ID: `lentic_clockss/us-transportation-search` |
| **Zapier** | Use the [Apify integration](https://zapier.com/apps/apify) → "Run Actor" action |
| **LangChain** | See Python example below |
| **MCP** | Connect via `npx @anthropic-ai/mcp apify` → this Actor is auto-discoverable |

**Python (LangChain AI agent):**

```python
from langchain_apify import ApifyActorsTool

tool = ApifyActorsTool("lentic_clockss/us-transportation-search")
result = tool.invoke({"searchTerms": ["Tesla recall"], "includeVehicleSafety": True, "maxResultsPerSource": 5})
```

→ Browse all Actors: [apify.com/lentic\_clockss](https://apify.com/lentic_clockss)

***

### Also Available

- **Postman Collection**: [Fork and test in Postman](https://www.postman.com/kaneliu10/sip-data-products-api) — pre-built requests with example responses
- **GitHub**: [Collection source files](https://github.com/kaneliu120/sip-api-collections) — import JSON into any API client
- **Direct API**: `https://opendata.best/api/v1/data` — use with any HTTP client and your API key

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords or location names to search across transportation datasets (e.g. 'Manhattan', 'Brooklyn', 'I-95'). Each term is searched across all enabled product categories in parallel.

## `includeVehicleSafety` (type: `boolean`):

Search crash reports and vehicle inspection records: Chicago crash reports (crashes and involved vehicles), NYC motor vehicle collisions, and NJ vehicle inspection data.

## `includeTrafficData` (type: `boolean`):

Search traffic volumes, MTA ridership, and violation records: NY AADT counts, MTA bridge/tunnel traffic, MTA subway ridership, NY E-ZPass usage, NY traffic ticket convictions, and NY traffic tickets.

## `includeInfrastructure` (type: `boolean`):

Search highway infrastructure and finance datasets: fuel tax collections, federal highway funding (FHWA), HPMS county-level road data, national road mileage, and USDOT transit urbanized area statistics.

## `includeRegistrations` (type: `boolean`):

Search driver and vehicle registration datasets: national licensed driver counts, NY driver licenses, NY DMV office locations, NY vehicle registrations, Washington State EV registrations, and NY highway mileage. Off by default due to high data volume.

## `maxResultsPerSource` (type: `integer`):

Maximum rows to return per SIP product per search term (SIP gateway caps at 200).

## `sipApiKey` (type: `string`):

SIP gateway X-API-Key. For local testing only — prefer the SIP\_API\_KEY environment variable on Apify so keys are not stored in run input.

## Actor input object example

```json
{
  "searchTerms": [
    "Manhattan"
  ],
  "includeVehicleSafety": true,
  "includeTrafficData": true,
  "includeInfrastructure": true,
  "includeRegistrations": false,
  "maxResultsPerSource": 50
}
```

# Actor output Schema

## `transportRecords` (type: `string`):

Dataset containing crash reports, vehicle inspections, traffic statistics, highway data, and driver registrations from 21 US transportation data sources.

# 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 = {
    "searchTerms": [
        "Manhattan"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/us-transportation-search").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 = { "searchTerms": ["Manhattan"] }

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/us-transportation-search").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 '{
  "searchTerms": [
    "Manhattan"
  ]
}' |
apify call lentic_clockss/us-transportation-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lentic_clockss/us-transportation-search",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Transportation Data API",
        "description": "Search 21 US transportation data sources — traffic crashes, vehicle inspections, MTA ridership, highway infrastructure, fuel tax, driver registrations, and EV data. Returns normalized results from USDOT, NHTSA, NY DMV, Chicago DOT, and state agencies via SIP Public Data Gateway.",
        "version": "0.1",
        "x-build-id": "phWC2AgUjts5giee9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~us-transportation-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-us-transportation-search",
                "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/lentic_clockss~us-transportation-search/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-us-transportation-search",
                "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/lentic_clockss~us-transportation-search/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-us-transportation-search",
                "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": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords or location names to search across transportation datasets (e.g. 'Manhattan', 'Brooklyn', 'I-95'). Each term is searched across all enabled product categories in parallel.",
                        "default": [
                            "Manhattan"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeVehicleSafety": {
                        "title": "Include vehicle safety data",
                        "type": "boolean",
                        "description": "Search crash reports and vehicle inspection records: Chicago crash reports (crashes and involved vehicles), NYC motor vehicle collisions, and NJ vehicle inspection data.",
                        "default": true
                    },
                    "includeTrafficData": {
                        "title": "Include traffic & transit data",
                        "type": "boolean",
                        "description": "Search traffic volumes, MTA ridership, and violation records: NY AADT counts, MTA bridge/tunnel traffic, MTA subway ridership, NY E-ZPass usage, NY traffic ticket convictions, and NY traffic tickets.",
                        "default": true
                    },
                    "includeInfrastructure": {
                        "title": "Include infrastructure & funding data",
                        "type": "boolean",
                        "description": "Search highway infrastructure and finance datasets: fuel tax collections, federal highway funding (FHWA), HPMS county-level road data, national road mileage, and USDOT transit urbanized area statistics.",
                        "default": true
                    },
                    "includeRegistrations": {
                        "title": "Include registrations & licensing data",
                        "type": "boolean",
                        "description": "Search driver and vehicle registration datasets: national licensed driver counts, NY driver licenses, NY DMV office locations, NY vehicle registrations, Washington State EV registrations, and NY highway mileage. Off by default due to high data volume.",
                        "default": false
                    },
                    "maxResultsPerSource": {
                        "title": "Max results per source",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum rows to return per SIP product per search term (SIP gateway caps at 200).",
                        "default": 50
                    },
                    "sipApiKey": {
                        "title": "SIP API Key (local testing only)",
                        "type": "string",
                        "description": "SIP gateway X-API-Key. For local testing only — prefer the SIP_API_KEY environment variable on Apify so keys are not stored in run input."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
