# FMCSA Carrier Safety Suite (`mooseandraven/fmcsa-carrier-safety-suite`) Actor

Vets a list of motor carriers (by DOT number, name, or docket number) against FMCSA's official QCMobile API: registration snapshot, BASIC safety percentiles, operating authority, and out-of-service status, with optional change-monitoring across scheduled runs.

- **URL**: https://apify.com/mooseandraven/fmcsa-carrier-safety-suite.md
- **Developed by:** [Moose & Raven](https://apify.com/mooseandraven) (community)
- **Categories:** Lead generation, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 carrier records

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

## FMCSA Carrier Safety Suite (Snapshot + BASIC Scores + Authority/OOS + Insurance-Lapse)

Vets a list of motor carriers (by USDOT number, legal/DBA name, or MC docket number) against
FMCSA's official data, returning a normalized registration snapshot, BASIC safety percentiles,
operating authority, out-of-service orders, and insurance on-file/required status — with optional
change-monitoring for scheduled runs (flags OOS orders, authority/safety-rating changes, insurance
lapses, and BASIC percentile shifts since the last run).

**Live-validated** against the real API with a real webKey — every field name and nesting shape
in this README and `OUTPUT_SCHEMA.md` is confirmed against real responses, not assumed from
FMCSA's own docs (which turned out to be missing several fields, including all insurance fields,
and had one field name wrong).

### What makes this different

This actor calls only the **official QCMobile REST API**
(`mobile.fmcsa.dot.gov/qc/services`), which FMCSA built and documents explicitly "to encourage
development of products, tools or services." It does not scrape SAFER, the live SMS carrier
profile pages, or `li-public.fmcsa.dot.gov`. That distinction matters here specifically because
the SMS website (`ai.fmcsa.dot.gov/SMS`) runs CAPTCHA + Cloudflare anti-bot protection —
confirmed during an access screen before this actor was built — so it is treated as a target that
actively resists automation and is out of scope.

Every other DOT/carrier actor we surveyed bundles at most a plain registration snapshot. This one
adds BASIC percentiles, authority status, out-of-service orders, insurance on-file/required flags,
and safety rating in the same normalized record, plus optional run-over-run change flagging for
scheduled monitoring, not just one-shot lookups. The insurance-lapse capability in particular is
a real signal not commonly offered through an official, non-scraping channel.

### How it works

- **Try it with no key at all**: leave `dotNumbers`/`carrierNames`/`docketNumbers` empty and
  `enableNewAuthorityFeed` on (the default) to see newly-registered motor carriers from FMCSA's
  official Company Census File — a separate, keyless public API. No signup needed for this part.
- **Bring your own FMCSA QCMobile webKey** (`fmcsaWebKey` input) to look up specific carriers by
  `dotNumbers`, `carrierNames`, and/or `docketNumbers` — names and docket numbers are resolved to
  USDOT numbers first (one carrier can match multiple names). Register a free developer account
  via Login.gov at `mobile.fmcsa.dot.gov` — no cost, not affiliated with Apify. Each run uses
  *your* key only; usage is never pooled across customers. Only required when you actually
  request a carrier lookup — not needed for the new-authority feed alone.
- For each resolved carrier, fetches the registration snapshot (which itself includes insurance
  on-file/required flags, safety rating, authority status, and crash/inspection stats — all in one
  call) and, optionally, BASIC percentiles, a fuller authority record, cargo authority, operation
  classification, and out-of-service orders.
- **Insurance-lapse detection**: the base snapshot includes `bipd`/`bond`/`cargo` insurance
  `OnFile` (a dollar-amount-like value) and `Required` ("Y"/"N"/"u") flags. A carrier with
  insurance required but nothing on file is a live, real, and — during testing — actually
  observed condition (a real carrier's `bipdInsuranceRequired: "Y"` with `bipdInsuranceOnFile:
  "0"`). `monitorMode` flags transitions into/out of this state.
- Optional **change-monitoring** (`monitorMode`): compares this run's snapshot for each carrier
  against the last run's (Apify key-value store) and emits a separate change-flag record for
  anything that shifted — allowed-to-operate status, out-of-service order count, safety rating,
  an insurance-lapse transition, or a watched BASIC percentile. Designed for scheduled runs
  watching a fixed carrier list (e.g. a broker's active lane partners, a factoring company's
  client roster). Confirmed live: a second run against unchanged data produces zero false-positive
  change flags.
- A **quota guard** (`maxRecordsPerRun`) caps carriers processed per run.
- **Fails the whole run immediately on an invalid webKey**, rather than quietly retrying the same
  bad key against every carrier and reporting a misleadingly "successful" zero-record run.
- Optional **new-authority feed** (`enableNewAuthorityFeed`): surfaces newly-registered motor
  carriers from FMCSA's official Company Census File (a separate, keyless, public Socrata API at
  `data.transportation.gov`) — no `fmcsaWebKey` usage or QCMobile quota consumed for this part.
  Supports the same `monitorMode` incremental-checkpoint pattern as carrier snapshots.

### Limitations (read before you rely on this)

- **Insurance-lapse detection is flag-level, not full policy detail.** You get on-file/required
  booleans and a dollar-amount-like figure per insurance type, not the insurer name, policy
  number, or effective date a human would see on `li-public.fmcsa.dot.gov`. That fuller detail
  remains out of scope — `li-public.fmcsa.dot.gov` is a live query portal with no documented API
  or stated automation invitation, and this actor avoids scraping government portals wherever a
  sanctioned alternative exists. The flag-level data is genuinely useful on its own (it's exactly
  what's needed to answer "does this carrier still have insurance on file") and comes from the
  same sanctioned QCMobile call as everything else.
- **Only 5 of 7 BASIC categories are available.** Hazmat and Crash Indicator BASICs are not
  publicly disclosed by FMCSA at all (confirmed via their own SMS documentation) — no actor, ours
  included, can legitimately offer them without non-public access.
- **Name search can return multiple carriers per name** (fuzzy match) and is capped at the API's
  first-50-results behavior; for precise vetting, prefer `dotNumbers`.
- **`oosDate` on the base snapshot is historical, not necessarily current** — it's the date the
  carrier was *last* placed out of service, which could be old news. The `oos` array (fetched
  separately, on by default) is the authoritative "does this carrier have an order on file right
  now" signal.

### Pricing model (proposed, not yet live)

Pay-per-event, to be finalized at publish time:
- `carrier-record` — per carrier snapshot returned (bundles registration + insurance flags +
  safety rating + BASICs + authority + OOS orders)
- `new-authority-record` — per newly-registered carrier returned by the new-authority feed
- `monitor-run` — one charge per scheduled monitor-mode run, in addition to per-carrier charges

### Input

Key fields (see the Input tab for the full form): `fmcsaWebKey` (bring your own — only needed
for carrier lookups, not for the new-authority feed), `dotNumbers`, `carrierNames`,
`docketNumbers`, `includeBasics`, `includeAuthority`, `includeCargoCarried`,
`includeOperationClassification`, `includeOos`, `monitorMode`, `maxRecordsPerRun`,
`enableNewAuthorityFeed` (on by default), `newAuthorityLookbackDays`, `newAuthorityStateFilter`,
`censusAppToken`.

### Output

Each dataset item has a `recordType` of `"carrier-safety-snapshot"`, `"carrier-change-flag"`,
`"new-authority"`, `"new-authority-status"` (only when the new-authority feed was truncated or
skipped), or `"monitor-config-warning"` (only when a carrier's monitor-mode config changed
between runs). See the Output tab for the full field reference.

### Local development

````

npm install
npm test                # recorded-fixture unit tests, no webKey needed
npx apify-cli run       # local end-to-end run — requires a real fmcsaWebKey in
\# storage/key\_value\_stores/default/INPUT.json

````

### Support

Built and maintained by Moose & Raven. Questions or issues: support@mooseandraven.com.

# Actor input Schema

## `fmcsaWebKey` (type: `string`):

Your own free FMCSA QCMobile API webKey (register a developer account via Login.gov at mobile.fmcsa.dot.gov). Only required if dotNumbers, carrierNames, or docketNumbers is set — the new-authority feed below is a separate, keyless public API and works with no key at all. This actor calls the official QCMobile REST API only — it does not scrape SAFER, the SMS website, or li-public.fmcsa.dot.gov. Your key's usage is yours alone; this actor never pools multiple customers behind one key.
## `dotNumbers` (type: `array`):

USDOT numbers to vet, one lookup per number.
## `carrierNames` (type: `array`):

Legal/DBA names to search (fuzzy match, may return multiple carriers per name — capped at the API's first-50-results limit per name).
## `docketNumbers` (type: `array`):

Motor carrier docket numbers to look up. Format confirmed live: plain numeric string (e.g. "329366"), NOT prefixed with "MC-" — a prefixed value is a different string to the API and will silently return zero results, not an error.
## `includeBasics` (type: `boolean`):

Fetch the 5 publicly-reported BASIC percentile scores (Unsafe Driving, Hours-of-Service/Fatigued Driving, Driver Fitness, Controlled Substances/Alcohol, Vehicle Maintenance) for each carrier. Hazmat and Crash Indicator BASICs are not publicly disclosed by FMCSA and are not available via this API.
## `includeAuthority` (type: `boolean`):

Fetch operating authority details for each carrier.
## `includeCargoCarried` (type: `boolean`):

Fetch the types of cargo each carrier is authorized to haul.
## `includeOperationClassification` (type: `boolean`):

Fetch each carrier's operation classification (e.g. interstate/intrastate, for-hire/private).
## `includeOos` (type: `boolean`):

Fetch any out-of-service orders on file for each carrier — the authoritative OOS signal (the base carrier snapshot has no boolean out-of-service field; OOS status is order-based).
## `monitorMode` (type: `boolean`):

When on, the actor compares this run's snapshot for each carrier against the last run's (via Apify key-value store) and emits an additional change-flag record for anything that shifted: allowed-to-operate status, out-of-service order count, safety rating, BIPD/bond/cargo insurance lapse state, or a BASIC percentile crossing a reporting threshold. Designed for scheduled runs monitoring a fixed carrier list. Charges one monitor-run PPE event in addition to per-carrier events.
## `maxRecordsPerRun` (type: `integer`):

Safety cap on total carriers looked up in one run (shared with the new-authority feed, if enabled). Set to 0 for no cap.
## `enableNewAuthorityFeed` (type: `boolean`):

Fetch newly-registered motor carriers from FMCSA's official Company Census File (data.transportation.gov Socrata API — no key required, distinct from the QCMobile carrier-lookup API above). Does not require dotNumbers/carrierNames/docketNumbers to be set, or fmcsaWebKey. On by default so a run with no input configured still produces real, keyless results.
## `newAuthorityLookbackDays` (type: `integer`):

How many days back to look for newly-registered carriers when monitorMode is off, or on the very first monitorMode run. Later monitorMode runs use the last run's checkpoint instead.
## `newAuthorityStateFilter` (type: `string`):

Optional 2-letter US state code to restrict the new-authority feed to carriers physically located in that state.
## `censusAppToken` (type: `string`):

Optional Socrata app token (free, from data.transportation.gov) for the new-authority feed, raising the anonymous-tier throttling ceiling if you hit it. Not required for normal use.

## Actor input object example

```json
{
  "dotNumbers": [],
  "carrierNames": [],
  "docketNumbers": [],
  "includeBasics": true,
  "includeAuthority": true,
  "includeCargoCarried": false,
  "includeOperationClassification": false,
  "includeOos": true,
  "monitorMode": false,
  "maxRecordsPerRun": 500,
  "enableNewAuthorityFeed": true,
  "newAuthorityLookbackDays": 7
}
````

# 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("mooseandraven/fmcsa-carrier-safety-suite").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("mooseandraven/fmcsa-carrier-safety-suite").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 mooseandraven/fmcsa-carrier-safety-suite --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mooseandraven/fmcsa-carrier-safety-suite",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FMCSA Carrier Safety Suite",
        "description": "Vets a list of motor carriers (by DOT number, name, or docket number) against FMCSA's official QCMobile API: registration snapshot, BASIC safety percentiles, operating authority, and out-of-service status, with optional change-monitoring across scheduled runs.",
        "version": "0.1",
        "x-build-id": "i5edC8OgFtcQV51at"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mooseandraven~fmcsa-carrier-safety-suite/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mooseandraven-fmcsa-carrier-safety-suite",
                "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/mooseandraven~fmcsa-carrier-safety-suite/runs": {
            "post": {
                "operationId": "runs-sync-mooseandraven-fmcsa-carrier-safety-suite",
                "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/mooseandraven~fmcsa-carrier-safety-suite/run-sync": {
            "post": {
                "operationId": "run-sync-mooseandraven-fmcsa-carrier-safety-suite",
                "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": {
                    "fmcsaWebKey": {
                        "title": "FMCSA QCMobile API webKey (only needed for carrier lookups)",
                        "type": "string",
                        "description": "Your own free FMCSA QCMobile API webKey (register a developer account via Login.gov at mobile.fmcsa.dot.gov). Only required if dotNumbers, carrierNames, or docketNumbers is set — the new-authority feed below is a separate, keyless public API and works with no key at all. This actor calls the official QCMobile REST API only — it does not scrape SAFER, the SMS website, or li-public.fmcsa.dot.gov. Your key's usage is yours alone; this actor never pools multiple customers behind one key."
                    },
                    "dotNumbers": {
                        "title": "USDOT numbers to look up",
                        "type": "array",
                        "description": "USDOT numbers to vet, one lookup per number.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "carrierNames": {
                        "title": "Carrier names to search",
                        "type": "array",
                        "description": "Legal/DBA names to search (fuzzy match, may return multiple carriers per name — capped at the API's first-50-results limit per name).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "docketNumbers": {
                        "title": "MC docket numbers to look up",
                        "type": "array",
                        "description": "Motor carrier docket numbers to look up. Format confirmed live: plain numeric string (e.g. \"329366\"), NOT prefixed with \"MC-\" — a prefixed value is a different string to the API and will silently return zero results, not an error.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeBasics": {
                        "title": "Include BASIC safety percentiles",
                        "type": "boolean",
                        "description": "Fetch the 5 publicly-reported BASIC percentile scores (Unsafe Driving, Hours-of-Service/Fatigued Driving, Driver Fitness, Controlled Substances/Alcohol, Vehicle Maintenance) for each carrier. Hazmat and Crash Indicator BASICs are not publicly disclosed by FMCSA and are not available via this API.",
                        "default": true
                    },
                    "includeAuthority": {
                        "title": "Include operating authority status",
                        "type": "boolean",
                        "description": "Fetch operating authority details for each carrier.",
                        "default": true
                    },
                    "includeCargoCarried": {
                        "title": "Include cargo authority details",
                        "type": "boolean",
                        "description": "Fetch the types of cargo each carrier is authorized to haul.",
                        "default": false
                    },
                    "includeOperationClassification": {
                        "title": "Include operation classification",
                        "type": "boolean",
                        "description": "Fetch each carrier's operation classification (e.g. interstate/intrastate, for-hire/private).",
                        "default": false
                    },
                    "includeOos": {
                        "title": "Include out-of-service orders",
                        "type": "boolean",
                        "description": "Fetch any out-of-service orders on file for each carrier — the authoritative OOS signal (the base carrier snapshot has no boolean out-of-service field; OOS status is order-based).",
                        "default": true
                    },
                    "monitorMode": {
                        "title": "Change-monitoring mode",
                        "type": "boolean",
                        "description": "When on, the actor compares this run's snapshot for each carrier against the last run's (via Apify key-value store) and emits an additional change-flag record for anything that shifted: allowed-to-operate status, out-of-service order count, safety rating, BIPD/bond/cargo insurance lapse state, or a BASIC percentile crossing a reporting threshold. Designed for scheduled runs monitoring a fixed carrier list. Charges one monitor-run PPE event in addition to per-carrier events.",
                        "default": false
                    },
                    "maxRecordsPerRun": {
                        "title": "Max carriers per run (safety guard)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Safety cap on total carriers looked up in one run (shared with the new-authority feed, if enabled). Set to 0 for no cap.",
                        "default": 500
                    },
                    "enableNewAuthorityFeed": {
                        "title": "Enable new-authority feed",
                        "type": "boolean",
                        "description": "Fetch newly-registered motor carriers from FMCSA's official Company Census File (data.transportation.gov Socrata API — no key required, distinct from the QCMobile carrier-lookup API above). Does not require dotNumbers/carrierNames/docketNumbers to be set, or fmcsaWebKey. On by default so a run with no input configured still produces real, keyless results.",
                        "default": true
                    },
                    "newAuthorityLookbackDays": {
                        "title": "New-authority lookback window (days)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "How many days back to look for newly-registered carriers when monitorMode is off, or on the very first monitorMode run. Later monitorMode runs use the last run's checkpoint instead.",
                        "default": 7
                    },
                    "newAuthorityStateFilter": {
                        "title": "New-authority state filter",
                        "type": "string",
                        "description": "Optional 2-letter US state code to restrict the new-authority feed to carriers physically located in that state."
                    },
                    "censusAppToken": {
                        "title": "Socrata app token (optional)",
                        "type": "string",
                        "description": "Optional Socrata app token (free, from data.transportation.gov) for the new-authority feed, raising the anonymous-tier throttling ceiling if you hit it. Not required for normal use."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```