# Copart UK Scraper — Salvage Car Auction Data (`studio-amba/copart-uk-scraper`) Actor

Scrape live salvage car auctions from Copart UK (copart.co.uk). Search by keyword or filter by make, model, year, damage and title category. Extract damage, CAT title, odometer, estimated value, current bid, sale date, yard and photos. No login or cookies required.

- **URL**: https://apify.com/studio-amba/copart-uk-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 result scrapeds

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

## Copart UK Scraper

Scrape live salvage vehicle auction lots from [copart.co.uk](https://www.copart.co.uk), the UK arm of the world's largest salvage auction platform. Roughly 17,500 lots are live at any time.

### Why use this actor?

Copart UK is where insurers, fleets and finance companies sell written-off and recovered vehicles. This actor extracts the full auction picture per lot: damage type, UK salvage title category (CAT B/C/D/N/S/U), odometer, Copart's estimated retail value, the current bid and the sale date. That combination is what salvage dealers, parts breakers, vehicle exporters and price analysts need to spot underpriced lots, track damage-adjusted market values, or feed repair-margin models. No login or cookies are required.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Free-text search across all lots (e.g. `"BMW"`, `"Golf GTI"`, `"Transit"`). Leave empty to scrape all live lots. |
| `make` | String | No | Exact make filter (e.g. `"Ford"`, `"Vauxhall"`) |
| `model` | String | No | Exact model filter (e.g. `"Fiesta"`, `"3 Series"`) |
| `yearFrom` | Integer | No | Only lots from this model year or newer |
| `yearTo` | Integer | No | Only lots up to this model year |
| `primaryDamage` | String | No | Damage filter, e.g. `"Front End"`, `"Rear End"`, `"Water/Flood"` |
| `titleCategory` | String | No | UK salvage title category: `CAT B`, `CAT C`, `CAT D`, `CAT N`, `CAT S`, `CAT U`, `CAT X` |
| `maxResults` | Integer | No | Maximum lots to return (default: 100) |
| `proxyConfiguration` | Object | No | Proxy settings. The default Apify proxy works. |

All filters can be combined. An empty input returns the newest lots across the whole catalogue.

#### Supported damage types

`All Over`, `Burn`, `Burn - Engine`, `Burn - Interior`, `Frame Damage Reported`, `Front End`, `Hail`, `Mechanical`, `Minor Dents/Scratches`, `Missing/Altered VIN`, `Normal Wear`, `Partial/Incomplete Repair`, `Parts`, `Previous Repair`, `Rear End`, `Replaced VIN`, `Rollover`, `Side`, `Stripped`, `Top/Roof`, `Undercarriage`, `Vandalism`, `Water/Flood`

The value is matched case-insensitively against Copart's live damage list, so partial matches like `"front"` work too.

### Output

Each result is one auction lot:

| Field | Type | Example |
|-------|------|---------|
| `lotNumber` | String | `"51237446"` |
| `name` | String | `"2012 BMW 3 SERIES 318D M SPORT 5DR"` |
| `make` | String | `"BMW"` |
| `model` | String | `"3 SERIES"` |
| `trim` | String | `"318d M Sport 5dr"` |
| `year` | Integer | `2012` |
| `primaryDamage` | String | `"SIDE"` |
| `secondaryDamage` | String | `"FRONT END"` |
| `titleType` | String | `"CAT B - BREAKER"` |
| `condition` | String | `"RUNS AND DRIVES"` |
| `odometer` | Number | `154053` (miles) |
| `estimatedValue` | Number | `2643` (GBP) |
| `repairCost` | Number | Copart's repair estimate, GBP |
| `currentBid` | Number | `225` |
| `buyItNowPrice` | Number | Buy It Now price when offered |
| `currency` | String | `"GBP"` |
| `saleDate` | String | ISO 8601 auction date |
| `saleStatus` | String | `"Pure Sale"`, `"Minimum Bid"`, ... |
| `yard` | String | `"SANDY"` |
| `locationCity` | String | `"SANDY"` |
| `postcode` | String | `"SG19 2UB"` |
| `fuel` | String | `"DIESEL"` |
| `transmission` | String | `"6 SPEED MANUAL"` |
| `engine` | String | `"1995 cc"` |
| `colour` | String | `"SILVER"` |
| `bodyStyle` | String | `"ESTATE"` |
| `imageUrl` | String | Main lot photo URL |
| `url` | String | Direct lot page URL |
| `scrapedAt` | String | ISO 8601 collection timestamp |

### Example output

```json
{
    "lotNumber": "51237446",
    "name": "2012 BMW 3 SERIES 318D M SPORT 5DR",
    "make": "BMW",
    "model": "3 SERIES",
    "trim": "318d M Sport 5dr",
    "year": 2012,
    "primaryDamage": "SIDE",
    "secondaryDamage": "FRONT END",
    "titleType": "CAT B - BREAKER",
    "condition": "ENHANCED VEHICLES",
    "odometer": 154053,
    "estimatedValue": 2643,
    "repairCost": 0,
    "currentBid": 225,
    "buyItNowPrice": null,
    "currency": "GBP",
    "saleDate": "2026-07-13T09:00:00.000Z",
    "saleStatus": "Pure Sale",
    "yard": "SANDY",
    "locationCity": "SANDY",
    "postcode": "SG19 2UB",
    "fuel": "DIESEL",
    "transmission": "6 SPEED MANUAL",
    "engine": "1995 cc",
    "colour": "SILVER",
    "bodyStyle": "ESTATE",
    "imageUrl": "https://cs.copart.com/v1/AUTH_svc.pdoc00001/lpp/0526/3091b9e8477848218d5b610c679565ac_thb.jpg",
    "url": "https://www.copart.co.uk/lot/51237446/2012-bmw-3-series-318d-m-sport-5dr-sandy",
    "scrapedAt": "2026-07-11T18:58:58.381Z"
}
````

### How to scrape Copart UK data

1. Open the actor and press **Try for free** (or **Start** in your Apify Console).
2. Enter a search term (e.g. `BMW`) or set filters: make, model, year range, damage type, title category. Leaving everything empty scrapes the newest lots across the entire catalogue.
3. Set `maxResults` to the number of lots you need. The full catalogue is around 17,500 lots and scrapes in a few minutes because the actor pulls 100 lots per request.
4. Run the actor and download the results from the dataset tab as JSON, CSV or Excel.

To monitor auctions continuously, put the actor on an Apify Schedule (for example every 6 hours) and connect a webhook or one of the Apify integrations (Google Sheets, Make, Zapier) to push new lots wherever you need them.

### Use cases

- **Salvage dealers and breakers** — track incoming lots by damage type and title category before auction day
- **Vehicle exporters** — find CAT N/S repairables with low repair estimates
- **Parts sellers** — monitor CAT B breaker lots for specific makes and models
- **Price analysts and insurers** — build damage-adjusted price histories from estimated value vs final bids
- **Marketplace aggregators** — feed live UK salvage listings into your own search product

### Cost estimate

The actor is HTTP-only (no browser) and fetches 100 lots per request, so it is very cheap to run: scraping 1,000 lots uses roughly **0.01 compute units** plus a handful of proxy requests. The entire live catalogue (~17,500 lots) completes in a few minutes.

### Limitations

- VINs are masked on copart.co.uk for anonymous visitors, so this actor does not output VINs.
- Bids change in real time; `currentBid` is the value at scrape time. Re-run or schedule the actor for fresh bids.
- Sale dates are converted to UTC. UK yard sale times are typically 10:00–12:00 local time.
- Non-vehicle lots (machinery, general goods) are excluded automatically.
- Data comes from the public website and may change without notice. Respect the website's terms of service and use responsibly.

### Related scrapers

- [AutoTrader UK Scraper](https://apify.com/store?search=autotrader-uk-scraper) — used-car listings from the UK's largest marketplace
- [Car.gr Scraper](https://apify.com/store?search=car-gr-scraper) — Greek car marketplace
- [Polovni Automobili Scraper](https://apify.com/store?search=polovni-automobili-scraper) — Serbian car marketplace
- [Hasznaltauto Scraper](https://apify.com/store?search=hasznaltauto-scraper) — Hungarian car marketplace

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API — maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text search across all lots (e.g. 'BMW', 'Golf GTI', 'Transit'). Leave empty to scrape all live lots sorted by sale date.

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

Filter by vehicle make, exact match (e.g. 'BMW', 'Ford', 'Vauxhall'). Can be combined with the search query.

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

Filter by manufacturer model, exact match (e.g. '3 Series', 'Fiesta', 'Astra'). Best combined with a make.

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

Only lots from this model year or newer (e.g. 2015).

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

Only lots up to this model year (e.g. 2022).

## `primaryDamage` (type: `string`):

Filter by primary damage type as shown on Copart, e.g. 'Front End', 'Rear End', 'Side', 'Water/Flood', 'Burn', 'Rollover', 'Minor Dents/Scratches', 'Normal Wear', 'Mechanical'. Matched case-insensitively against Copart's live damage list.

## `titleCategory` (type: `string`):

Filter by UK salvage title category. CAT B = breaker, CAT S = structural repairable, CAT N = non-structural repairable, CAT U = used unrecorded.

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

Maximum number of auction lots to scrape. The API returns 100 lots per request, so large runs stay fast and cheap.

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

Proxy settings. Apify datacenter proxy (the default) works. If runs start failing with blocks, switch to RESIDENTIAL proxy with country GB.

## Actor input object example

```json
{
  "searchQuery": "BMW",
  "titleCategory": "all",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchQuery": "BMW",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/copart-uk-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 = {
    "searchQuery": "BMW",
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/copart-uk-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 '{
  "searchQuery": "BMW",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/copart-uk-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Copart UK Scraper — Salvage Car Auction Data",
        "description": "Scrape live salvage car auctions from Copart UK (copart.co.uk). Search by keyword or filter by make, model, year, damage and title category. Extract damage, CAT title, odometer, estimated value, current bid, sale date, yard and photos. No login or cookies required.",
        "version": "0.1",
        "x-build-id": "jw82PedykGJNRMF0f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~copart-uk-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-copart-uk-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/studio-amba~copart-uk-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-copart-uk-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/studio-amba~copart-uk-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-copart-uk-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Free-text search across all lots (e.g. 'BMW', 'Golf GTI', 'Transit'). Leave empty to scrape all live lots sorted by sale date."
                    },
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Filter by vehicle make, exact match (e.g. 'BMW', 'Ford', 'Vauxhall'). Can be combined with the search query."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Filter by manufacturer model, exact match (e.g. '3 Series', 'Fiesta', 'Astra'). Best combined with a make."
                    },
                    "yearFrom": {
                        "title": "Year From",
                        "minimum": 1950,
                        "maximum": 2035,
                        "type": "integer",
                        "description": "Only lots from this model year or newer (e.g. 2015)."
                    },
                    "yearTo": {
                        "title": "Year To",
                        "minimum": 1950,
                        "maximum": 2035,
                        "type": "integer",
                        "description": "Only lots up to this model year (e.g. 2022)."
                    },
                    "primaryDamage": {
                        "title": "Primary Damage",
                        "type": "string",
                        "description": "Filter by primary damage type as shown on Copart, e.g. 'Front End', 'Rear End', 'Side', 'Water/Flood', 'Burn', 'Rollover', 'Minor Dents/Scratches', 'Normal Wear', 'Mechanical'. Matched case-insensitively against Copart's live damage list."
                    },
                    "titleCategory": {
                        "title": "Title Category",
                        "enum": [
                            "all",
                            "CAT B",
                            "CAT C",
                            "CAT D",
                            "CAT N",
                            "CAT S",
                            "CAT U",
                            "CAT X"
                        ],
                        "type": "string",
                        "description": "Filter by UK salvage title category. CAT B = breaker, CAT S = structural repairable, CAT N = non-structural repairable, CAT U = used unrecorded.",
                        "default": "all"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of auction lots to scrape. The API returns 100 lots per request, so large runs stay fast and cheap.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Apify datacenter proxy (the default) works. If runs start failing with blocks, switch to RESIDENTIAL proxy with country GB.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
