# Bring a Trailer Auctions Scraper (`automation-lab/bringatrailer-auctions-scraper`) Actor

Extract live BaT auction listings with current bids, end times, countries, thumbnails, and public listing URLs for vehicle market analysis.

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

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Bring a Trailer Auctions Scraper

Extract live Bring a Trailer auction listings, bid levels, countries, end times, thumbnails, and auction URLs from public BaT pages.

### What does Bring a Trailer Auctions Scraper do?

Bring a Trailer Auctions Scraper turns the public BaT live auctions page into structured data.

It reads the server-rendered auction data exposed on Bring a Trailer.

It saves one dataset row per auction listing.

It is designed for recurring monitoring and market-intelligence workflows.

Use it to export active inventory, current bids, auction end times, country metadata, and listing URLs.

### Who is it for?

🚗 Collector-car dealers tracking desirable inventory.

📊 Auction analysts monitoring current bid levels.

🧾 Appraisers collecting comparable live-auction context.

💼 Pricing-intelligence teams building dashboards.

🔔 Enthusiasts watching categories and high-value vehicles.

### Why use this scraper?

Bring a Trailer is a high-signal collector-vehicle marketplace.

Manual monitoring takes time.

Structured exports make it easier to sort, filter, alert, and compare listings.

This actor provides repeatable data without requiring a login for public auction pages.

### What data can you extract?

The actor extracts auction listing records.

| Field | Description |
| --- | --- |
| `listingId` | Bring a Trailer listing ID |
| `title` | Auction title or vehicle headline |
| `year` | Vehicle year when exposed by BaT |
| `url` | Public auction URL |
| `currentBid` | Numeric current bid |
| `currentBidFormatted` | Formatted bid text |
| `currency` | Listing currency |
| `country` | Listing country |
| `countryCode` | Two-letter country code |
| `locationLatitude` | Latitude when provided |
| `locationLongitude` | Longitude when provided |
| `endTime` | Auction end time in ISO format |
| `endTimestamp` | Auction end timestamp |
| `noReserve` | Whether BaT marks the listing as no reserve |
| `premium` | Whether BaT marks the listing as premium |
| `repeatListing` | Repeat listing flag |
| `categories` | BaT category IDs |
| `thumbnailUrl` | Auction thumbnail image |
| `excerpt` | Short BaT listing summary |
| `sourceUrl` | Page that produced the row |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape Bring a Trailer auctions?

This actor uses pay-per-event pricing.

There is a $0.005 start fee per run.

Per auction listing pricing is tiered by Apify plan: Free $0.000031389, Bronze $0.000027295, Silver $0.00002129, Gold $0.000016377, Platinum $0.000010918, Diamond $0.00001.

A 100-listing run costs roughly $0.0082 on the Free tier before any platform/account-level adjustments.

Use `maxItems` to control cost.

Start with 100 auctions for a normal market snapshot.

Reduce `maxItems` when testing filters.

### Input options

`startUrls` accepts Bring a Trailer URLs.

Leave it empty to scrape `https://bringatrailer.com/auctions/`.

Use `maxItems` to cap saved records.

Use `minBid` to keep only listings above a bid threshold.

Use `countryCode` to keep only a country such as `US`, `CA`, or `GB`.

Use `includeExcerpt` to include or omit the listing summary text.

### Example input

```json
{
  "startUrls": [
    { "url": "https://bringatrailer.com/auctions/" }
  ],
  "maxItems": 100,
  "minBid": 0,
  "countryCode": "",
  "includeExcerpt": true
}
````

### Example output

```json
{
  "listingId": 116636262,
  "title": "Lot #250,000: 1985 Ferrari 288 GTO",
  "year": "1985",
  "url": "https://bringatrailer.com/listing/1985-ferrari-288-gto-2/",
  "currentBid": 6800000,
  "currentBidFormatted": "USD $6,800,000",
  "currency": "USD",
  "country": "United States",
  "countryCode": "US",
  "endTime": "2026-07-07T17:00:00.000Z",
  "noReserve": false,
  "premium": true,
  "thumbnailUrl": "https://bringatrailer.com/wp-content/uploads/example.jpg",
  "sourceUrl": "https://bringatrailer.com/auctions/",
  "scrapedAt": "2026-07-07T04:10:13.584Z"
}
```

### How to scrape live BaT auctions

1. Open the actor on Apify.

2. Keep the default `https://bringatrailer.com/auctions/` start URL.

3. Set `maxItems` to the number of active auctions you need.

4. Optionally set `minBid` or `countryCode`.

5. Run the actor.

6. Export the dataset as JSON, CSV, Excel, or via API.

### Monitoring workflow ideas

Run the actor every hour to track bid changes.

Send dataset rows into a database.

Compare `currentBid` and `endTime` between runs.

Trigger alerts for vehicles above or below thresholds.

Build dashboards for active collector-car inventory.

### Appraisal workflow ideas

Export active auctions for a specific market segment.

Filter by year, title keywords, country, or bid level in your downstream system.

Use `url` to open the original BaT listing for manual review.

Capture high-value lots before auction close.

### Dealer workflow ideas

Monitor active vehicles that match acquisition criteria.

Track countries and currencies.

Prioritize premium or no-reserve listings.

Use thumbnails for internal watchlists.

Combine BaT data with CRM notes.

### Tips for better results

Use the default auctions URL for the broadest active inventory snapshot.

Keep `maxItems` low while testing.

Use `countryCode` only when you know the exact country code.

Leave `includeExcerpt` enabled if you need vehicle context.

Disable `includeExcerpt` for smaller exports.

### Limitations

The actor extracts public information visible in BaT page data.

It does not log in to user accounts.

It does not bid, watch, message, or interact with auctions.

Direct listing URLs may have fewer structured fields than the live auctions index.

Historical sold-price analysis is outside this first version.

### Integrations

Send results to Google Sheets for manual review.

Load JSON into a warehouse for historical bid tracking.

Use webhooks to notify a Slack channel after each run.

Connect Apify datasets to Make or Zapier.

Query the dataset API from a pricing dashboard.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bringatrailer-auctions-scraper').call({
  startUrls: [{ url: 'https://bringatrailer.com/auctions/' }],
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/bringatrailer-auctions-scraper').call(run_input={
    'startUrls': [{'url': 'https://bringatrailer.com/auctions/'}],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(len(items))
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~bringatrailer-auctions-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://bringatrailer.com/auctions/"}],"maxItems":100}'
```

### MCP usage

Use the Apify MCP server with Claude Code or Claude Desktop.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/bringatrailer-auctions-scraper`

Claude Code setup:

```bash
claude mcp add apify-bat-auctions "https://mcp.apify.com/?tools=automation-lab/bringatrailer-auctions-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-bat-auctions": {
      "url": "https://mcp.apify.com/?tools=automation-lab/bringatrailer-auctions-scraper"
    }
  }
}
```

Example prompt:

"Run the Bring a Trailer Auctions Scraper for 100 current auctions and summarize the top current bids by country."

Another prompt:

"Scrape live BaT auctions and create a watchlist of premium listings ending soon."

### Legality

### Is it legal to scrape Bring a Trailer?

This actor extracts public data from public pages.

You are responsible for using the data lawfully.

Respect Bring a Trailer's terms, privacy rights, and applicable laws.

Do not use scraped data for spam or unauthorized automated interaction.

### FAQ

#### Why did I get fewer records than expected?

Filters such as `minBid` and `countryCode` can reduce the saved dataset size.

#### Can I scrape direct listing URLs?

Yes, but the live auctions page exposes richer structured auction fields.

### Troubleshooting

If the dataset is empty, check `maxItems`, `minBid`, and `countryCode` filters.

If a direct listing URL has null bid fields, use the live auctions page for richer structured data.

If a run stops early, lower `maxItems` and retry.

If BaT changes page structure, open an issue with a sample URL.

### Related scrapers

Explore related automation-lab actors on Apify for vehicle listings, marketplaces, lead lists, and pricing intelligence.

Use this actor as the Bring a Trailer source in a broader automotive data workflow.

### Changelog

Initial version extracts live Bring a Trailer auction listing data from public pages.

### Support

If you need a field that appears on BaT but is missing from the dataset, open a support request with a sample auction URL.

### Final notes

The best first run is the default input.

It is cheap, broad, and representative.

Increase `maxItems` when you are ready to monitor the full public inventory.

# Actor input Schema

## `startUrls` (type: `array`):

Bring a Trailer live auctions page URLs or direct listing URLs. Leave empty to scrape https://bringatrailer.com/auctions/.

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

Maximum number of auction records to save. The default BaT auctions page usually contains hundreds of active listings.

## `minBid` (type: `integer`):

Only save auctions with a current bid at or above this amount in the listing currency. Use 0 to keep all listings.

## `countryCode` (type: `string`):

Optional two-letter country code such as US, CA, GB, or DE. Leave empty to include all countries.

## `includeExcerpt` (type: `boolean`):

Include BaT's short listing summary/excerpt when available.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://bringatrailer.com/auctions/"
    }
  ],
  "maxItems": 20,
  "minBid": 0,
  "includeExcerpt": true
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://bringatrailer.com/auctions/"
        }
    ],
    "maxItems": 20,
    "minBid": 0,
    "countryCode": "",
    "includeExcerpt": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bringatrailer-auctions-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 = {
    "startUrls": [{ "url": "https://bringatrailer.com/auctions/" }],
    "maxItems": 20,
    "minBid": 0,
    "countryCode": "",
    "includeExcerpt": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bringatrailer-auctions-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 '{
  "startUrls": [
    {
      "url": "https://bringatrailer.com/auctions/"
    }
  ],
  "maxItems": 20,
  "minBid": 0,
  "countryCode": "",
  "includeExcerpt": true
}' |
apify call automation-lab/bringatrailer-auctions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bring a Trailer Auctions Scraper",
        "description": "Extract live BaT auction listings with current bids, end times, countries, thumbnails, and public listing URLs for vehicle market analysis.",
        "version": "0.1",
        "x-build-id": "L5FrUIOQlNliWkhMO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~bringatrailer-auctions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-bringatrailer-auctions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~bringatrailer-auctions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-bringatrailer-auctions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~bringatrailer-auctions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-bringatrailer-auctions-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Bring a Trailer live auctions page URLs or direct listing URLs. Leave empty to scrape https://bringatrailer.com/auctions/.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum auctions",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of auction records to save. The default BaT auctions page usually contains hundreds of active listings.",
                        "default": 20
                    },
                    "minBid": {
                        "title": "Minimum current bid",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only save auctions with a current bid at or above this amount in the listing currency. Use 0 to keep all listings.",
                        "default": 0
                    },
                    "countryCode": {
                        "title": "Country code filter",
                        "type": "string",
                        "description": "Optional two-letter country code such as US, CA, GB, or DE. Leave empty to include all countries."
                    },
                    "includeExcerpt": {
                        "title": "Include listing excerpt",
                        "type": "boolean",
                        "description": "Include BaT's short listing summary/excerpt when available.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
