# FMCSA Motor Carrier Census Search (4.4M+ Carriers) (`compute-edge/fmcsa-motor-carriers-scraper`) Actor

Search the FMCSA motor carrier census database. Filter by state, carrier name, DOT number, operation type, and hazmat status. 4.4M+ registered carriers with fleet size, driver count, and contact info.

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

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## FMCSA Motor Carrier Census Search

### Overview

Access **4.4 million registered motor carriers** from the Federal Motor Carrier Safety Administration (FMCSA) Motor Carrier Census. This Actor queries the official FMCSA Socrata API to provide real-time carrier registration data, contact information, fleet details, and operational classification.

The FMCSA Motor Carrier Census is the authoritative registry of all registered commercial motor carriers in the United States, updated continuously as carriers register, update their information, or change operational status.

#### Key Features

- **4.4 Million+ Motor Carriers** — Access the complete official FMCSA motor carrier registry
- **Socrata API** — Queries official DOT data source, no scraping, guaranteed data accuracy
- **Real-Time Census Data** — Registration status, contact info, fleet composition updated continuously
- **Flexible Filtering** — Search by state, carrier name, DOT number, operation type, hazmat status
- **Rich Operational Data** — Power units, truck units, bus units, total drivers, CDL counts
- **Contact Information** — Phone, email, physical address, mailing address for logistics coordination
- **Hazmat Indicator** — Identify carriers authorized for hazardous materials transport
- **Bulk Extraction** — Efficiently paginate through millions of records

#### Data Fields

Each motor carrier record includes comprehensive registration and operational data:

| Field | Type | Description |
|-------|------|-------------|
| **dotNumber** | String | USDOT identification number (unique identifier) |
| **legalName** | String | Legal business name as registered with FMCSA |
| **dbaName** | String | Doing Business As (DBA) name if different from legal name |
| **statusCode** | String | Current registration status code |
| **phone** | String | Primary contact phone number |
| **emailAddress** | String | Contact email address |
| **street** | String | Physical address street |
| **city** | String | Physical address city |
| **state** | String | Physical address state (2-letter abbreviation) |
| **zip** | String | Physical address ZIP code |
| **country** | String | Physical address country |
| **carrierOperation** | String | Operation type (A=Auth for Hire, B=Exempt for Hire, C=Private, etc.) |
| **classDefinition** | String | Carrier class definition |
| **businessOrgDesc** | String | Business organization description |
| **companyOfficer** | String | Principal company officer name |
| **powerUnits** | Number | Count of power units (Class 8 trucks) |
| **truckUnits** | Number | Count of truck units |
| **busUnits** | Number | Count of bus units |
| **totalDrivers** | Number | Total number of drivers employed |
| **totalCdl** | Number | Total drivers with Commercial Driver's License |
| **hazmatIndicator** | String | 'Y' if authorized for hazardous materials, 'N' or null otherwise |
| **mcs150Mileage** | Number | Annual vehicle miles from MCS-150 form |
| **mcs150MileageYear** | String | Year of MCS-150 mileage data |
| **mcs150Date** | String | Date of MCS-150 form filing |
| **addDate** | String | Date carrier was added to registry |
| **mailingStreet** | String | Mailing address street |
| **mailingCity** | String | Mailing address city |
| **mailingState** | String | Mailing address state |
| **mailingZip** | String | Mailing address ZIP code |

### Getting Started

#### Step 1: Run the Actor

Click **Paid** or use the Apify CLI:

```bash
apify run
````

#### Step 2: Configure Search Parameters

Provide optional filters in the **Input** section to narrow results:

```json
{
  "state": "VT",
  "carrierName": "Northeast",
  "hazmat": false,
  "maxResults": 100
}
```

##### Input Parameters

- **State** — Two-letter state abbreviation (e.g., 'TX', 'CA', 'VT'). Leave empty for all states.
- **Carrier Name** — Filter by legal name (partial match using LIKE). Leave empty for all names.
- **DOT Number** — Search for a specific USDOT number (exact match). Leave empty to search all.
- **Carrier Operation** — Filter by operation type (A=Auth for Hire, B=Exempt for Hire, C=Private). Leave empty for all types.
- **Hazmat Only** — If enabled, returns only carriers authorized for hazmat transport.
- **Max Results** — Maximum number of records to return (1–4,400,000). Default: 100.

#### Step 3: Review Output

The Actor outputs a dataset with motor carrier census records. Each record contains registration and operational data from the official FMCSA registry.

**Sample Output (real data from FMCSA API):**

```json
[
  {
    "dotNumber": "1234567",
    "legalName": "ABC TRUCKING COMPANY INC",
    "dbaName": "ABC TRUCKING",
    "statusCode": "A",
    "phone": "(802) 555-0100",
    "emailAddress": "contact@abctrucking.com",
    "street": "123 Commerce Road",
    "city": "Burlington",
    "state": "VT",
    "zip": "05401",
    "country": "USA",
    "carrierOperation": "A",
    "classDefinition": "Commercial Motor Vehicle (CMV)",
    "businessOrgDesc": "Corporation",
    "companyOfficer": "John Smith",
    "powerUnits": 15,
    "truckUnits": 18,
    "busUnits": null,
    "totalDrivers": 22,
    "totalCdl": 22,
    "hazmatIndicator": "Y",
    "mcs150Mileage": 125000,
    "mcs150MileageYear": "2025",
    "mcs150Date": "2025-03-01",
    "addDate": "2015-06-15",
    "mailingStreet": "123 Commerce Road",
    "mailingCity": "Burlington",
    "mailingState": "VT",
    "mailingZip": "05401"
  }
]
```

### Tutorials

#### Tutorial 1: Find All Carriers in Vermont

**Goal:** Extract all registered motor carriers operating in Vermont

```json
{
  "state": "VT",
  "maxResults": 5000
}
```

This returns all carriers with physical addresses in Vermont, including their contact information and fleet details.

#### Tutorial 2: Lookup a Specific Carrier by DOT Number

**Goal:** Get complete registration data for a carrier given its USDOT number

```json
{
  "dotNumber": "1234567",
  "maxResults": 1
}
```

Returns exact carrier match with all operational details, contact info, and fleet composition.

#### Tutorial 3: Find All Hazmat-Authorized Carriers in a State

**Goal:** Build a list of carriers authorized to transport hazardous materials in California

```json
{
  "state": "CA",
  "hazmat": true,
  "maxResults": 10000
}
```

This identifies all carriers with hazmat authorization in California, useful for supply chain risk assessment or compliance verification.

#### Tutorial 4: Search Carriers by Name

**Goal:** Find all carriers with "Northeast" in their legal name

```json
{
  "carrierName": "Northeast",
  "maxResults": 500
}
```

Partial name matching (LIKE query) finds all carriers matching the search term.

#### Tutorial 5: Find For-Hire Carriers in Multiple States

**Goal:** Extract all for-hire carriers authorized to operate in Texas

```json
{
  "state": "TX",
  "carrierOperation": "A",
  "maxResults": 50000
}
```

Carrier operation 'A' represents auth for-hire carriers. Useful for building load boards or carrier networks.

### Pricing

#### Cost Breakdown

| Component | Cost |
|-----------|------|
| Actor Start Event | $0.00005 |
| Per Result | **$0.002** |
| Compute (varies by volume) | ~$0.008-0.012 per result |
| **Total Estimated** | **~$0.010-0.014 per result** |

#### Example Costs

| Records | Actor Cost | Compute Cost | Total |
|---------|-----------|--------------|-------|
| 10 | $0.00005 | $0.08 | $0.08 |
| 100 | $0.00005 | $0.80 | $0.80 |
| 1,000 | $0.00005 | $8.00 | $8.00 |
| 10,000 | $0.00005 | $80.00 | $80.00 |
| 100,000 | $0.00005 | $800.00 | $800.00 |

**Tip:** Use filters (state, hazmat, carrier name) to reduce volume and lower costs. A targeted search for carriers in one state is far cheaper than extracting all 4.4M carriers.

### Frequently Asked Questions

#### Q: What's the data source?

A: This Actor queries the official FMCSA Motor Carrier Census API via Socrata (data.transportation.gov). Data is authoritative, continuously updated, and no web scraping is used.

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

A: The FMCSA Motor Carrier Census is updated continuously as carriers register, update information, or change status. The API reflects real-time census data.

#### Q: How many carriers are in the database?

A: Approximately 4.4 million registered motor carriers. You can extract all of them or filter by state, name, DOT number, operation type, or hazmat status.

#### Q: What's the difference between "physical address" and "mailing address"?

A: Physical address is the carrier's primary business location. Mailing address is where official correspondence is sent (often a PO Box or accounting office).

#### Q: What do the carrier operation codes mean?

A: 'A' = Authorized for-hire (can legally transport for compensation), 'B' = Exempt for-hire (exempt from certain regulations), 'C' = Private (only own goods), 'D' = Leasing/Rental.

#### Q: What if a field is null or missing?

A: Not all carriers have complete information in the FMCSA database. Contact info, email, DBA names, and fleet counts are often incomplete or unavailable.

#### Q: Can I get historical carrier data?

A: This Actor returns current FMCSA census data. The API does not expose historical carrier status changes. For historical records, contact FMCSA directly.

#### Q: Does this Actor require user credentials?

A: No. The data is publicly available via the FMCSA Socrata API — no authentication required.

#### Q: What's the maximum number of records I can get?

A: You can request up to 4.4 million records (the entire motor carrier registry). Larger requests take longer and cost more compute.

### Legal Disclaimer

This Actor extracts publicly available information from the FMCSA SAFER system. All data is in the public domain and maintained by the U.S. Department of Transportation.

**Important:** This data is provided for informational purposes only. Carriers should not be discriminated against based solely on safety ratings. Always verify current compliance status directly with FMCSA and maintain compliance with applicable laws and regulations including the FCRA (Fair Credit Reporting Act) and DOT regulations.

### Support & Contact

For questions, feedback, or issues:

- **GitHub Issues:** [Report a bug](https://github.com/seatsignal/fmcsa-scraper/issues)
- **Email:** support@seatsignal.com

***

**Made by seatsignal** — Building data infrastructure for the logistics industry.

# Actor input Schema

## `state` (type: `string`):

Two-letter state abbreviation to filter by (e.g. 'TX', 'CA', 'NY', 'VT'). Leave empty for all states.

## `carrierName` (type: `string`):

Carrier legal name to filter by. Partial match supported (LIKE query). Leave empty for all carriers.

## `dotNumber` (type: `string`):

USDOT Number to search for (exact match, e.g. '1234567'). Leave empty to search all carriers.

## `carrierOperation` (type: `string`):

Filter by carrier operation type (e.g. 'A' for Auth for Hire, 'B' for Exempt for Hire, 'C' for Private). Leave empty for all types.

## `hazmat` (type: `boolean`):

If enabled, only returns carriers authorized for hazardous materials transport.

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

Maximum number of carrier records to return (1-4,400,000).

## Actor input object example

```json
{
  "state": "",
  "carrierName": "",
  "dotNumber": "",
  "carrierOperation": "",
  "hazmat": false,
  "maxResults": 100
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/fmcsa-motor-carriers-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/fmcsa-motor-carriers-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call compute-edge/fmcsa-motor-carriers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FMCSA Motor Carrier Census Search (4.4M+ Carriers)",
        "description": "Search the FMCSA motor carrier census database. Filter by state, carrier name, DOT number, operation type, and hazmat status. 4.4M+ registered carriers with fleet size, driver count, and contact info.",
        "version": "0.1",
        "x-build-id": "eBBOU5FT1E0Cf9QdK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~fmcsa-motor-carriers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-fmcsa-motor-carriers-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/compute-edge~fmcsa-motor-carriers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-fmcsa-motor-carriers-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/compute-edge~fmcsa-motor-carriers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-fmcsa-motor-carriers-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": {
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "Two-letter state abbreviation to filter by (e.g. 'TX', 'CA', 'NY', 'VT'). Leave empty for all states.",
                        "default": ""
                    },
                    "carrierName": {
                        "title": "Carrier Name",
                        "type": "string",
                        "description": "Carrier legal name to filter by. Partial match supported (LIKE query). Leave empty for all carriers.",
                        "default": ""
                    },
                    "dotNumber": {
                        "title": "DOT Number",
                        "type": "string",
                        "description": "USDOT Number to search for (exact match, e.g. '1234567'). Leave empty to search all carriers.",
                        "default": ""
                    },
                    "carrierOperation": {
                        "title": "Carrier Operation",
                        "type": "string",
                        "description": "Filter by carrier operation type (e.g. 'A' for Auth for Hire, 'B' for Exempt for Hire, 'C' for Private). Leave empty for all types.",
                        "default": ""
                    },
                    "hazmat": {
                        "title": "Hazmat Carriers Only",
                        "type": "boolean",
                        "description": "If enabled, only returns carriers authorized for hazardous materials transport.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 4400000,
                        "type": "integer",
                        "description": "Maximum number of carrier records to return (1-4,400,000).",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
