# BoatTrader Scraper (`parseforge/boattrader-scraper`) Actor

Scrape boat listings from BoatTrader.com. Extract prices, make, model, year, length, engine specs, fuel type, hull material, dealer info, and images. Filter by boat type, condition, price, and length. Optional detail page enrichment with full specifications and descriptions.

- **URL**: https://apify.com/parseforge/boattrader-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, E-commerce, Automation
- **Stats:** 5 total users, 1 monthly users, 72.7% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🚢 BoatTrader Boat Listings Scraper

Whether you're a boat dealer tracking competitor pricing, a marine industry analyst building market databases, or a buyer monitoring prices for a specific make and model, this tool makes it easy to collect structured boat listing data from BoatTrader.com - the largest online marketplace for buying and selling boats.

> **The BoatTrader Scraper collects boat listings with titles, prices, specs, engine details, seller info, and images. Filter by make, type, condition, price range, length, and location.**

### ✨ What Does It Do

- 🚢 **Boat listings** - collect titles, years, makes, models, and prices from thousands of boat listings
- ⚙️ **Full specifications** - extract length, beam, fuel type, hull material, and boat class for every listing
- 🔧 **Engine details** - get engine make, model, type, total power, and hours (with full details enabled)
- 👤 **Seller information** - dealer name, seller type, and location (city, state, zip code)
- 📸 **All images** - collect every photo from the listing when Include Full Details is enabled
- 🔍 **Flexible search** - filter by make, boat type, condition, price range, length, location, or paste any BoatTrader URL

### 🔧 Input

- **Start URL** - paste any BoatTrader search URL directly (overrides all filter fields below)
- **Max Items** - how many boat listings to collect (free users get 10 items, paid users up to 1,000,000)
- **Make** - boat manufacturer (e.g., Bayliner, Boston Whaler, Sea Ray)
- **Boat Type** - filter by Power, Sail, PWC, or Small Boats
- **Condition** - filter by New or Used
- **Min Price / Max Price** - price range in USD
- **Min Length / Max Length** - length range in feet
- **Location** - city or state to search near
- **Include Full Details** - fetch each listing's detail page for complete specs, description, engine data, and all images

```json
{
    "make": "Bayliner",
    "boatType": "power",
    "condition": "used",
    "maxItems": 10,
    "includeDetails": true
}
````

### 📊 Output

Each boat listing includes up to 30+ data fields. Download as JSON, CSV, or Excel.

| 📌 Field | 📄 Description |
|----------|---------------|
| 🖼️ imageUrl | Primary listing photo |
| 📋 title | Full boat title (year, make, model) |
| 💰 price | Listing price |
| 💳 monthlyPayment | Estimated monthly payment |
| 🔗 url | Direct link to listing on BoatTrader |
| 🏭 make | Boat manufacturer |
| 🚢 model | Boat model name |
| 📅 year | Model year |
| ✅ condition | New or Used |
| 📐 length | Boat length in feet |
| ⛽ fuelType | Fuel type (gasoline, diesel, etc.) |
| 🔧 engineMake | Engine manufacturer |
| ⚡ totalPower | Total engine horsepower |
| 📍 location | Seller city, state, zip code |
| 👤 sellerName | Dealer or private seller name |

```json
{
    "imageUrl": "https://images.boattrader.com/resize/1/73/19/2025-bayliner-vr6-bowrider-io-power-9737319-1.jpg",
    "title": "2025 Bayliner VR6 Bowrider I/O",
    "price": 59770,
    "priceFormatted": "$59,770",
    "monthlyPayment": "$441/mo*",
    "url": "https://www.boattrader.com/boat/2025-bayliner-vr6-bowrider-i-o-9737319/",
    "listingId": "9737319",
    "make": "Bayliner",
    "model": "VR6 Bowrider I/O",
    "year": 2025,
    "condition": "New",
    "boatClass": "Bowrider",
    "length": "22ft",
    "lengthFt": 22,
    "fuelType": "gasoline",
    "engineMake": "MERCRUISER",
    "engineModel": "250 M MPI A1 4.5L",
    "engineType": "inboard",
    "totalPower": "250hp",
    "engineHours": null,
    "location": "MILTON, WA, 98354",
    "city": "MILTON",
    "state": "WA",
    "zipCode": "98354",
    "sellerName": "Union Marine (Fife Store)",
    "sellerType": "enhanced listing",
    "description": "Full listing description text...",
    "images": [
        "https://images.boattrader.com/resize/1/73/19/2025-bayliner-vr6-bowrider-io-1.jpg",
        "https://images.boattrader.com/resize/1/73/19/2025-bayliner-vr6-bowrider-io-2.jpg"
    ],
    "scrapedAt": "2026-04-07T16:52:04.533Z"
}
```

### 💎 Why Choose the BoatTrader Scraper?

| Feature | Our Tool | Manual BoatTrader Search |
|---------|----------|------------------------|
| Batch collection | ✅ Up to 1M listings | ❌ Browse one at a time |
| Multiple filters | ✅ Make, type, condition, price, length | ⚠️ Limited search |
| Full engine specs | ✅ Make, model, power, hours | ⚠️ Click each listing |
| Structured output | ✅ JSON, CSV, Excel | ❌ HTML pages only |
| Automated scheduling | ✅ Daily/weekly monitoring | ❌ Manual visits |
| All listing images | ✅ Complete photo gallery | ⚠️ View one at a time |

### 📋 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - set your make, type, condition, price range, and length filters (or paste a BoatTrader URL)
3. **Run It** - click "Start" and get structured boat data in seconds

No coding, no setup, no manual browsing required.

### 🎯 Business Use Cases

- 🚢 **Boat dealers** - monitor competitor inventory and pricing across makes, models, and regions
- 📊 **Marine industry analysts** - build comprehensive market databases and generate pricing reports by region or type
- ⚓ **Yacht brokers** - find new listings matching client requirements and compare pricing across similar boats
- 🛥️ **Boat buyers** - track prices for specific makes and models and get notified about new listings
- 📈 **Data analysts** - build datasets for marine market analysis and create dashboards tracking boat market trends
- 🏗️ **Marine manufacturers** - monitor market positioning and pricing for your models vs competitors

### ❓ FAQ

🚢 **What is BoatTrader?**
BoatTrader.com is the largest online marketplace for buying and selling boats in the United States. It features listings from dealers and private sellers for power boats, sailboats, PWCs, and small boats.

🔍 **What's the difference between basic and detailed mode?**
Basic mode returns title, price, year, make, model, listing URL, image, location, and seller name from search results. Enabling "Include Full Details" adds condition, boat class, length, beam, fuel type, hull material, full engine specs, description, and all images.

📋 **What boat types are supported?**
Power boats, sailboats, PWC (personal watercraft), and small boats. Within those categories you can filter by make, condition, price, and length.

⏱️ **How long does a run take?**
Basic mode: hundreds of listings per minute. With details enabled, each listing takes an additional 0.5-1 second for the detail page request.

📅 **Can I schedule regular runs?**
Yes. Set up a scheduled run to monitor new listings or price changes daily, weekly, or at any interval you choose.

### 🔗 Integrate BoatTrader Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate boat market monitoring workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Get alerts when new boats match your criteria
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notified in your team channel
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export boat data to spreadsheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

### 💡 Recommended Actors

Looking for more marine and vehicle data tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| YATCO Yacht Listing Scraper | Collect yacht listing data from YATCO marketplace | [Link](https://apify.com/parseforge/yatco-scraper) |
| Click\&Boat Scraper | Extract boat rental listings from Click\&Boat | [Link](https://apify.com/parseforge/click-boat-scraper) |
| Fraser Yachts Scraper | Collect luxury yacht listings from Fraser Yachts | [Link](https://apify.com/parseforge/fraseryachts-scraper) |
| duPont Registry Scraper | Collect luxury vehicle and real estate listings | [Link](https://apify.com/parseforge/dupont-registry-scraper) |
| Copart Public Search Scraper | Extract vehicle auction data from Copart | [Link](https://apify.com/parseforge/copart-public-search-scraper) |

**Pro Tip:** 💡 Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your needs.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to BoatTrader.com or any of its subsidiaries. It accesses only publicly available data from BoatTrader.com.

# Actor input Schema

## `startUrl` (type: `string`):

Direct BoatTrader search URL (e.g. https://www.boattrader.com/boats/type-power/make-bayliner/). If provided, filter fields below are ignored.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

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

Boat manufacturer (e.g. Bayliner, Boston Whaler, Sea Ray)

## `boatType` (type: `string`):

Filter by boat type

## `condition` (type: `string`):

Filter by boat condition

## `minPrice` (type: `integer`):

Minimum price in USD

## `maxPrice` (type: `integer`):

Maximum price in USD

## `minLength` (type: `integer`):

Minimum boat length in feet

## `maxLength` (type: `integer`):

Maximum boat length in feet

## `location` (type: `string`):

City or state to search near

## `includeDetails` (type: `boolean`):

Fetch each listing's detail page for full specs, description, engine info, and all images. Slower but much more data.

## Actor input object example

```json
{
  "maxItems": 10,
  "includeDetails": false
}
```

# Actor output Schema

## `boats` (type: `string`):

Complete dataset with all scraped boat listings

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

Overview of boat listings with key fields

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/boattrader-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/boattrader-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 '{
  "maxItems": 10
}' |
apify call parseforge/boattrader-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BoatTrader Scraper",
        "description": "Scrape boat listings from BoatTrader.com. Extract prices, make, model, year, length, engine specs, fuel type, hull material, dealer info, and images. Filter by boat type, condition, price, and length. Optional detail page enrichment with full specifications and descriptions.",
        "version": "1.0",
        "x-build-id": "jZd9ihbLWPec3OZk2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~boattrader-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-boattrader-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/parseforge~boattrader-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-boattrader-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/parseforge~boattrader-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-boattrader-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": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "Direct BoatTrader search URL (e.g. https://www.boattrader.com/boats/type-power/make-bayliner/). If provided, filter fields below are ignored."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    },
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Boat manufacturer (e.g. Bayliner, Boston Whaler, Sea Ray)"
                    },
                    "boatType": {
                        "title": "Boat Type",
                        "enum": [
                            "power",
                            "sail",
                            "pwc",
                            "small"
                        ],
                        "type": "string",
                        "description": "Filter by boat type"
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "new",
                            "used"
                        ],
                        "type": "string",
                        "description": "Filter by boat condition"
                    },
                    "minPrice": {
                        "title": "Min Price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in USD"
                    },
                    "maxPrice": {
                        "title": "Max Price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in USD"
                    },
                    "minLength": {
                        "title": "Min Length (ft)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum boat length in feet"
                    },
                    "maxLength": {
                        "title": "Max Length (ft)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum boat length in feet"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or state to search near"
                    },
                    "includeDetails": {
                        "title": "Include Full Details",
                        "type": "boolean",
                        "description": "Fetch each listing's detail page for full specs, description, engine info, and all images. Slower but much more data.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
