# Copart Salvage Auction Scraper — Lots, Bids & VINs (`bovi/copart-lot-scraper`) Actor

Scrape Copart salvage vehicle auction lots by keyword or search URL. Returns lot number, VIN, year/make/model/trim, damage, title code, odometer, current bid, buy-it-now price, auction time, location, and images.

- **URL**: https://apify.com/bovi/copart-lot-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** E-commerce, Automation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $22.59 / 1,000 lot-items

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

**Extract salvage auction data from Copart in seconds — lot details, VINs, damage, title codes, odometer readings, bids, and full image galleries for any make, model, or keyword search.**

This Copart scraper delivers structured salvage car data at scale. Search by keyword, make/model/year, or paste any Copart search URL to pull every matching lot. Includes inline VIN decode — engine type, transmission, drivetrain, fuel type, and cylinder count are enriched automatically from the VIN for each lot.

### Features

- **Search by keyword or URL** — enter a make/model keyword (e.g. `honda`, `ford f-150`) or paste a full `copart.com/lotSearchResults` URL to replicate any existing search
- **Filter by make, model, and year range** — narrow results without touching the URL
- **Inline VIN enrichment** — engine, transmission, drive, fuel, and cylinders decoded and merged per lot
- **Full image gallery** — complete photo list per lot, not just the thumbnail
- **Auto-paginate** — walks all result pages up to your `maxItems` cap
- **Session resilience** — if the site's session expires mid-run, the scraper re-warms automatically and continues from where it left off; no lost data
- **Pay per result** — you are charged only for lots actually returned, never for pages browsed

### What data you get

Each record is one salvage lot. Fields are sourced from Copart's search and detail endpoints and merged into a single flat object.

| Field | Fill rate | Notes |
|---|---|---|
| `lot_number` | 100% | Copart lot identifier |
| `vin` | 100% | Full 17-char VIN |
| `year` | 100% | Model year |
| `make` | 100% | e.g. HONDA, FORD |
| `model` | 100% | e.g. CIVIC, F-150 |
| `trim` | 100% | Trim level when listed |
| `engine_type` | 100% | e.g. 3.5L V6, 4 CYL |
| `cylinders` | 100% | Cylinder count |
| `transmission` | 100% | AUTO / MANUAL |
| `drive` | 100% | AWD / FWD / RWD / 4WD |
| `fuel` | 100% | GASOLINE / HYBRID / ELECTRIC / DIESEL |
| `color` | 100% | Exterior color |
| `has_keys` | 100% | Y / N |
| `lot_condition` | 100% | Lot condition description |
| `primary_damage` | 100% | e.g. FRONT END, HAIL |
| `sale_location` | 100% | Auction yard name |
| `sale_status` | 100% | e.g. ON MINIMUM BID, FUTURE SALE |
| `auction_time` | 100% | ISO-8601 UTC datetime |
| `item_url` | 100% | Direct link to the lot page |
| `currency` | 100% | Always USD |
| `estimated_retail_value` | ~93% | Estimated ACV in USD; not set on all lots |
| `title_code` | ~93% | e.g. CERT-D, NO-TITLE; depends on state filing |
| `odometer` | ~80% | Miles; EXEMPT on some salvage titles |
| `body_style` | Varies | Not always provided by the source |
| `secondary_damage` | Varies | Present when a second damage area is noted |
| `seller` | Varies | Seller company name when disclosed |
| `lot_notes` | Varies | Free-text auction notes |
| `current_bid` | Pre-auction | Null on lots not yet at auction ("Pure Sale" stage) |
| `buy_it_now_price` | Pre-auction | Null on lots without an active BIN price |
| `images` | 100% | List of full-resolution CDN image URLs |
| `latitude` / `longitude` | 100% | Yard coordinates |
| `scraped_at` | 100% | ISO-8601 UTC timestamp of the run |

### Input

```json
{
  "query": "honda civic",
  "make": "HONDA",
  "model": "CIVIC",
  "yearFrom": 2018,
  "yearTo": 2023,
  "maxItems": 200,
  "fetchDetails": true,
  "fetchImages": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

You can also pass `"searchUrl"` instead of `"query"` — paste any `copart.com/lotSearchResults` URL and the scraper replicates that exact search. When `searchUrl` is provided it takes priority over `query`.

**Key parameters:**

| Parameter | Default | Description |
|---|---|---|
| `query` | — | Keyword search (required unless `searchUrl` is set) |
| `searchUrl` | — | Paste a Copart search URL to replicate it |
| `make` | — | Optional make filter (e.g. `FORD`) |
| `model` | — | Optional model filter (e.g. `MUSTANG`) |
| `yearFrom` / `yearTo` | — | Optional year range |
| `maxItems` | 100 | Max lots to return; set to `0` for unlimited |
| `fetchDetails` | true | Fetch richer detail fields (VIN, secondary damage, retail value) |
| `fetchImages` | true | Fetch full image gallery per lot |

### Pricing

**Pay per result — $0.02329 per lot** (charge event: `lot-item`).

You are only charged for lots actually pushed to your dataset. Browsing pages, retrying sessions, and fetching images do not add to your bill. At this rate, 1,000 lots costs roughly $23.29 — about 10% below the comparable market rate.

The actor runs on a residential proxy for reliable access; proxy usage is billed to your Apify account at platform rates as part of the normal run cost, with no surcharge from us.

### FAQ

**Do I need an API key or a Copart account?**
No. The scraper needs no Copart login, no API key, and no external credentials. Just run it — it handles the site's challenge internally using a residential proxy and a resilient browser warm-up.

**Are current bids and buy-it-now prices always present?**
Not always. Copart has a "Pure Sale" pre-auction stage where lots are listed but bidding has not opened yet. On those lots `current_bid` and `buy_it_now_price` will be `null`. Once the lot enters active auction these fields populate normally.

**Can I scrape a specific Copart search I already have open?**
Yes. Copy the URL from your browser — it will look like `https://www.copart.com/lotSearchResults/?...` — and paste it into the `searchUrl` input. The scraper decodes all the filter parameters automatically.

**How many lots can I pull per run?**
There is no hard limit on our side. Set `maxItems: 0` to pull all available results. Copart's search returns up to 10,000 lots per query (100 pages × 100 lots). For larger datasets, combine multiple keyword or make/model runs.

**What happens if the site's session drops mid-run?**
The scraper detects session expiry (the site's challenge cookie has a ~25-minute TTL) and re-warms the session automatically, then resumes from the same page. You will not lose data already collected, and you are not charged twice for the same lot.

### Use cases

- **Salvage dealers and rebuilders** — monitor specific makes, models, and damage types across all Copart yards to build a live acquisition pipeline
- **Parts businesses** — identify high-value donor cars (low-odometer, specific engine/trim) before they go to auction
- **Insurance and total-loss analysts** — track title codes, estimated retail values, and primary damage distributions for reserve-setting and subrogation research
- **Arbitrage and export** — compare Copart hammer prices against retail and export market values; VIN data plugs straight into any valuation API
- **Research and pricing tools** — build salvage-car price indices, damage-to-ACV models, or regional supply dashboards using structured lot data
- **Notification systems** — run the scraper on a schedule and alert on new lots matching your target criteria before auction day

# Actor input Schema

## `query` (type: `string`):

Keyword search for lots (e.g. 'honda', 'toyota camry', 'ford f-150'). Either this or searchUrl is required.

## `searchUrl` (type: `string`):

Paste a copart.com/lotSearchResults URL to replicate that search. If provided, overrides the query field.

## `make` (type: `string`):

Filter by vehicle make (e.g. HONDA, TOYOTA, FORD). Case-insensitive.

## `model` (type: `string`):

Filter by vehicle model (e.g. CIVIC, CAMRY, F-150). Case-insensitive.

## `yearFrom` (type: `integer`):

Minimum model year. Leave blank for no lower bound.

## `yearTo` (type: `integer`):

Maximum model year. Leave blank for no upper bound.

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

Maximum number of auction lots to return. Default 100. Set to 0 for unlimited (you are charged per lot returned).

## `fetchDetails` (type: `boolean`):

ON (default): fetch the lot detail page for richer fields — VIN, secondary damage, title code, estimated retail value. OFF: fast mode — search-API fields only.

## `fetchImages` (type: `boolean`):

ON (default): fetch full-resolution image URLs for each lot. OFF: thumbnail only (faster).

## `proxyConfiguration` (type: `object`):

Required. Copart uses Imperva Incapsula — a residential proxy is needed to clear the JS challenge. Apify RESIDENTIAL proxy is billed to your run at no extra cost.

## Actor input object example

```json
{
  "query": "honda",
  "maxItems": 100,
  "fetchDetails": true,
  "fetchImages": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset of Copart lot records (lot\_number, vin, year, make, model, trim, engine, transmission, drive, fuel, body\_style, color, odometer, primary\_damage, secondary\_damage, title\_code, sale\_status, sale\_location, auction\_time, current\_bid, buy\_it\_now, estimated\_retail\_value, currency, images, item\_url, scraped\_at).

# 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 = {
    "query": "honda",
    "maxItems": 100,
    "fetchDetails": true,
    "fetchImages": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/copart-lot-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 = {
    "query": "honda",
    "maxItems": 100,
    "fetchDetails": True,
    "fetchImages": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/copart-lot-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 '{
  "query": "honda",
  "maxItems": 100,
  "fetchDetails": true,
  "fetchImages": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bovi/copart-lot-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bovi/copart-lot-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Copart Salvage Auction Scraper — Lots, Bids & VINs",
        "description": "Scrape Copart salvage vehicle auction lots by keyword or search URL. Returns lot number, VIN, year/make/model/trim, damage, title code, odometer, current bid, buy-it-now price, auction time, location, and images.",
        "version": "0.1",
        "x-build-id": "hVUBbTuS8idZI43Pg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~copart-lot-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-copart-lot-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/bovi~copart-lot-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-copart-lot-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/bovi~copart-lot-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-copart-lot-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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword search for lots (e.g. 'honda', 'toyota camry', 'ford f-150'). Either this or searchUrl is required."
                    },
                    "searchUrl": {
                        "title": "Copart search URL (optional)",
                        "type": "string",
                        "description": "Paste a copart.com/lotSearchResults URL to replicate that search. If provided, overrides the query field."
                    },
                    "make": {
                        "title": "Make filter (optional)",
                        "type": "string",
                        "description": "Filter by vehicle make (e.g. HONDA, TOYOTA, FORD). Case-insensitive."
                    },
                    "model": {
                        "title": "Model filter (optional)",
                        "type": "string",
                        "description": "Filter by vehicle model (e.g. CIVIC, CAMRY, F-150). Case-insensitive."
                    },
                    "yearFrom": {
                        "title": "Year from (optional)",
                        "minimum": 1900,
                        "type": "integer",
                        "description": "Minimum model year. Leave blank for no lower bound."
                    },
                    "yearTo": {
                        "title": "Year to (optional)",
                        "minimum": 1900,
                        "type": "integer",
                        "description": "Maximum model year. Leave blank for no upper bound."
                    },
                    "maxItems": {
                        "title": "Max lots to scrape",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of auction lots to return. Default 100. Set to 0 for unlimited (you are charged per lot returned).",
                        "default": 100
                    },
                    "fetchDetails": {
                        "title": "Fetch lot details",
                        "type": "boolean",
                        "description": "ON (default): fetch the lot detail page for richer fields — VIN, secondary damage, title code, estimated retail value. OFF: fast mode — search-API fields only.",
                        "default": true
                    },
                    "fetchImages": {
                        "title": "Fetch full image gallery",
                        "type": "boolean",
                        "description": "ON (default): fetch full-resolution image URLs for each lot. OFF: thumbnail only (faster).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Required. Copart uses Imperva Incapsula — a residential proxy is needed to clear the JS challenge. Apify RESIDENTIAL proxy is billed to your run at no extra cost.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```