# FMCSA Motor Carrier Leads Scraper (`automation-lab/fmcsa-motor-carrier-leads-scraper`) Actor

🚚 Find public USDOT/FMCSA motor carrier leads by DOT number, company name, state, city, fleet size, and new-carrier add date.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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 Motor Carrier Leads Scraper

Extract public USDOT/FMCSA motor carrier records for trucking lead generation, compliance checks, factoring outreach, insurance prospecting, and freight broker research.

The actor queries the public U.S. Department of Transportation Socrata dataset directly. It does not scrape blocked SAFER pages, does not require a login, and does not use a browser.

### What does FMCSA Motor Carrier Leads Scraper do?

FMCSA Motor Carrier Leads Scraper turns public motor-carrier registry data into a clean Apify dataset.

It can look up known USDOT numbers, search legal or DBA company names, discover carriers by physical-address state or city, and build new-carrier feeds by FMCSA add date.

Each output row is one carrier record with DOT number, name, status, phone, address, fleet size, drivers, add date, docket fields, and source URL.

### Who is it for?

- 🚚 Freight brokers building regional carrier lists.
- 💳 Factoring companies looking for small fleets and new authorities.
- 🛡️ Insurance teams prospecting commercial trucking accounts.
- 📋 Compliance teams checking public carrier status and contact data.
- 📈 B2B sales teams enriching transportation company CRMs.
- 🧑‍💻 Data teams that need repeatable FMCSA API extraction on Apify.

### Why use this actor?

The public FMCSA dataset contains millions of rows, but it is not packaged for lead workflows. This actor adds user-friendly filters, pagination, typed output, Apify datasets, API access, and pay-per-result charging.

You can run it on a schedule, export CSV or JSON, connect it to webhooks, or call it from your own code.

### Data source

The actor uses the public Socrata endpoint hosted at `data.transportation.gov`.

SAFER/FMCSA HTML pages are not used as the extraction source because they can return 403 responses from automated environments. Dataset rows include a SAFER snapshot URL for user reference.

### What data can I extract?

| Field | Description |
| --- | --- |
| `dotNumber` | USDOT number |
| `legalName` | Carrier legal name |
| `dbaName` | DBA name when available |
| `statusCode` | FMCSA status code, for example active/inactive |
| `carrierOperation` | Carrier operation code |
| `businessOrg` | Business organization description |
| `phone` | Public phone number |
| `physicalAddress` | Physical street/city/state/ZIP |
| `mailingAddress` | Mailing street/city/state/ZIP |
| `powerUnits` | Power unit count |
| `drivers` | Total driver count |
| `mcs150Mileage` | MCS-150 mileage |
| `addDate` | FMCSA add date |
| `docketPrefix` | Docket prefix |
| `docketNumber` | Docket number |
| `sourceUrl` | SAFER carrier snapshot URL |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape FMCSA motor carrier leads?

This actor uses pay-per-event pricing.

- A small start fee is charged once per run.
- A per-item fee is charged for each carrier record saved.
- Larger Apify subscription tiers receive lower per-item prices.

Use `maxItems` to control cost before running a broad state or city search.

### Input options

#### Lookup filters

- `dotNumbers` — exact DOT/USDOT number lookup.
- `companyNames` — partial legal name or DBA search.
- `states` — physical-address state codes such as `TX`, `CA`, or `FL`.
- `cities` — physical-address city names.

#### Carrier filters

- `onlyActive` — default `true`, keeps active carriers only.
- `addedSince` — build a new-carrier feed from `YYYY-MM-DD` or `YYYYMMDD`.
- `minPowerUnits` — exclude carriers below a fleet-size threshold.
- `minDrivers` — exclude carriers below a driver-count threshold.

#### Run limits

- `maxItems` — maximum records to save.
- `pageSize` — Socrata page size for each request.

### Example input: active Texas leads

```json
{
  "states": ["TX"],
  "onlyActive": true,
  "minPowerUnits": 1,
  "maxItems": 100
}
````

### Example input: DOT lookup

```json
{
  "dotNumbers": ["284470", "1000006"],
  "onlyActive": false,
  "maxItems": 25
}
```

### Example input: new carrier feed

```json
{
  "states": ["FL", "GA"],
  "addedSince": "2024-01-01",
  "onlyActive": true,
  "minPowerUnits": 1,
  "maxItems": 250
}
```

### Output example

```json
{
  "dotNumber": "284470",
  "legalName": "INDEPENDENT TRANSPORTATION SERVICES INC",
  "dbaName": null,
  "statusCode": "I",
  "phone": "6022339778",
  "city": "PHOENIX",
  "state": "AZ",
  "powerUnits": 2,
  "drivers": 5,
  "addDate": "1986-12-30",
  "sourceUrl": "https://safer.fmcsa.dot.gov/query.asp?...",
  "scrapedAt": "2026-06-26T00:00:00.000Z"
}
```

### How to run it

1. Open the actor on Apify.
2. Choose DOT lookup, company search, or state/city lead discovery.
3. Keep the default `maxItems` for a cheap first run.
4. Run the actor.
5. Export the dataset as CSV, JSON, Excel, XML, or RSS.

### Tips for better lead lists

- Use `onlyActive: true` for sales prospecting.
- Use `addedSince` for new-authority or new-carrier monitoring.
- Combine `states` with `minPowerUnits` to focus on operating fleets.
- Disable `onlyActive` for historical or compliance research.
- Use smaller `maxItems` when testing a new geography.

### Integrations

This actor works well in these workflows:

- CRM enrichment: export FMCSA carrier leads to HubSpot, Salesforce, or Airtable.
- Outreach: send new carrier rows to email or calling workflows.
- Compliance monitoring: schedule repeat runs and compare DOT status changes.
- Market research: build state-level snapshots of active trucking companies.
- Freight sales: segment carriers by power units, drivers, state, and city.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fmcsa-motor-carrier-leads-scraper').call({
  states: ['TX'],
  onlyActive: true,
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/fmcsa-motor-carrier-leads-scraper').call(run_input={
    'states': ['TX'],
    'onlyActive': True,
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~fmcsa-motor-carrier-leads-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"states":["TX"],"onlyActive":true,"maxItems":100}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or other MCP clients through Apify MCP.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/fmcsa-motor-carrier-leads-scraper
```

Claude Code setup:

```bash
claude mcp add apify-fmcsa --transport http "https://mcp.apify.com/?tools=automation-lab/fmcsa-motor-carrier-leads-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-fmcsa": {
      "url": "https://mcp.apify.com/?tools=automation-lab/fmcsa-motor-carrier-leads-scraper"
    }
  }
}
```

Example prompts:

- “Find 100 active FMCSA motor carriers in Texas with at least one power unit.”
- “Look up these DOT numbers and return company names, phone numbers, and fleet size.”
- “Build a new FMCSA carrier lead feed for Florida and Georgia since 2024-01-01.”

### Scheduling and monitoring

You can schedule the actor daily, weekly, or monthly. For new-carrier monitoring, set `addedSince` to a recent date and export new rows to your CRM or warehouse.

### Limits and reliability

The actor uses public Socrata API pagination and bounded retries. Very large runs may be throttled by the public endpoint, so increase volume gradually and keep `pageSize` reasonable.

### Legality

The actor extracts public U.S. government transportation records. You are responsible for using the data lawfully, respecting outreach rules, honoring do-not-call requirements where applicable, and complying with your local privacy and marketing regulations.

### FAQ

#### Is this an official FMCSA product?

No. This is an independent Apify actor that reads public data from a U.S. Department of Transportation open-data endpoint.

#### Do I need a Socrata app token?

No app token is required for normal runs. The actor uses gentle pagination and retries for the public endpoint.

### Troubleshooting

#### Why did I get fewer rows than maxItems?

Your filters may be narrow, or Socrata may not contain matching rows for the combination of state, city, add date, active status, fleet size, and driver count.

#### Why are some fields null?

FMCSA source records are not complete for every carrier. DBA name, mailing address, docket fields, and mileage can be missing.

#### Why does the source URL show a page that blocks bots?

The actor does not depend on that page. It is included as a human-readable SAFER reference. The extraction source is the public Socrata dataset.

### Related scrapers

Explore other Automation Lab actors:

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/business-email-finder

### Changelog

#### 0.1

Initial private build with DOT lookup, company-name search, state/city discovery, new-carrier add-date feed, fleet filters, typed output, and pay-per-result charging.

### Support

If you need a field that exists in the FMCSA public dataset but is not included yet, open an issue on the actor page and include your target workflow.

# Actor input Schema

## `dotNumbers` (type: `array`):

Optional list of DOT/USDOT numbers to look up directly.

## `companyNames` (type: `array`):

Optional legal or DBA names to search in FMCSA records.

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

Two-letter US state codes for lead discovery, e.g. TX, CA, FL.

## `cities` (type: `array`):

Optional city names for local lead discovery. Matching uses FMCSA physical-address city.

## `onlyActive` (type: `boolean`):

When enabled, only rows with status\_code = A are returned. Disable for compliance/history research.

## `addedSince` (type: `string`):

Optional new-carrier feed cutoff. Use YYYY-MM-DD or YYYYMMDD; compares against FMCSA add\_date.

## `minPowerUnits` (type: `integer`):

Return carriers with at least this many power units. Use 0 to disable.

## `minDrivers` (type: `integer`):

Return carriers with at least this many total drivers. Use 0 to disable.

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

Maximum FMCSA carrier rows to save to the dataset.

## `pageSize` (type: `integer`):

Internal page size for the public Socrata API. Smaller values are gentler; larger values can be faster.

## Actor input object example

```json
{
  "dotNumbers": [
    "284470"
  ],
  "companyNames": [],
  "states": [
    "TX"
  ],
  "cities": [],
  "onlyActive": true,
  "addedSince": "2024-01-01",
  "minPowerUnits": 1,
  "minDrivers": 0,
  "maxItems": 20,
  "pageSize": 100
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "dotNumbers": [
        "284470"
    ],
    "companyNames": [],
    "states": [
        "TX"
    ],
    "cities": [],
    "onlyActive": true,
    "addedSince": "2024-01-01",
    "minPowerUnits": 1,
    "minDrivers": 0,
    "maxItems": 20,
    "pageSize": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fmcsa-motor-carrier-leads-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 = {
    "dotNumbers": ["284470"],
    "companyNames": [],
    "states": ["TX"],
    "cities": [],
    "onlyActive": True,
    "addedSince": "2024-01-01",
    "minPowerUnits": 1,
    "minDrivers": 0,
    "maxItems": 20,
    "pageSize": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fmcsa-motor-carrier-leads-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 '{
  "dotNumbers": [
    "284470"
  ],
  "companyNames": [],
  "states": [
    "TX"
  ],
  "cities": [],
  "onlyActive": true,
  "addedSince": "2024-01-01",
  "minPowerUnits": 1,
  "minDrivers": 0,
  "maxItems": 20,
  "pageSize": 100
}' |
apify call automation-lab/fmcsa-motor-carrier-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FMCSA Motor Carrier Leads Scraper",
        "description": "🚚 Find public USDOT/FMCSA motor carrier leads by DOT number, company name, state, city, fleet size, and new-carrier add date.",
        "version": "0.1",
        "x-build-id": "GigLouaFQxgZdEPdp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fmcsa-motor-carrier-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fmcsa-motor-carrier-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~fmcsa-motor-carrier-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fmcsa-motor-carrier-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~fmcsa-motor-carrier-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fmcsa-motor-carrier-leads-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",
                "properties": {
                    "dotNumbers": {
                        "title": "USDOT numbers",
                        "type": "array",
                        "description": "Optional list of DOT/USDOT numbers to look up directly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyNames": {
                        "title": "Company names",
                        "type": "array",
                        "description": "Optional legal or DBA names to search in FMCSA records.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "Physical-address states",
                        "type": "array",
                        "description": "Two-letter US state codes for lead discovery, e.g. TX, CA, FL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Physical-address cities",
                        "type": "array",
                        "description": "Optional city names for local lead discovery. Matching uses FMCSA physical-address city.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "onlyActive": {
                        "title": "Only active carriers",
                        "type": "boolean",
                        "description": "When enabled, only rows with status_code = A are returned. Disable for compliance/history research.",
                        "default": true
                    },
                    "addedSince": {
                        "title": "Added since",
                        "type": "string",
                        "description": "Optional new-carrier feed cutoff. Use YYYY-MM-DD or YYYYMMDD; compares against FMCSA add_date."
                    },
                    "minPowerUnits": {
                        "title": "Minimum power units",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Return carriers with at least this many power units. Use 0 to disable.",
                        "default": 1
                    },
                    "minDrivers": {
                        "title": "Minimum drivers",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Return carriers with at least this many total drivers. Use 0 to disable.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Maximum carrier records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum FMCSA carrier rows to save to the dataset.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "Socrata page size",
                        "minimum": 10,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Internal page size for the public Socrata API. Smaller values are gentler; larger values can be faster.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```