# CarGurus Scraper — Car Dealer Leads with Phone & Ratings (`scrapersdelight/cargurus-dealer-scraper`) Actor

Scrape US car dealers from CarGurus as clean B2B leads: dealer name, phone, full address, star rating, review count, franchise make, live inventory, brands sold and price range. One row per dealer (deduped). Filter by make and condition. No login.

- **URL**: https://apify.com/scrapersdelight/cargurus-dealer-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Automation, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 per dealer lead returneds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## 🚗 CarGurus Car-Dealer Leads Scraper — Phone, Rating & Inventory

**Turn CarGurus into a clean list of *car dealers* — dealer name, phone, full address, star rating, review count, franchise make, live inventory count, the brands they sell, and their price range. One row per dealer (deduped by seller id), not one row per car. Filter by make and condition. No login, no API key.**

> 🕒 One row per dealer · 🇺🇸 US market · 📞 Phone + full address · ⭐ Star rating + review count · 📦 Live inventory + brands + price band · 🚫 No login or API key · 🔌 Straight from CarGurus' own page data

Most CarGurus scrapers hand you a wall of individual car listings and leave you to figure out who's actually selling them. **This one flips it around and gives you the dealer.** It walks the listings, collapses them to unique dealers, then opens each dealer's own CarGurus storefront to pull the details that make a real B2B lead: the **phone**, the full legal **address**, the CarGurus **star rating** and **review count**, how many cars they have live, and which brands + price band they play in. The result is a ready-to-use dealer prospect list for automotive SaaS, DMS/CRM, financing, insurance, parts, and wholesale outreach.

---

### What it does

- 🏢 **One clean row per dealer** — deduped by CarGurus seller id, so 40 cars from one dealer become a single lead, not 40 near-duplicates.
- 📞 **The contact + trust fields others skip** — `phone`, full legal `street` / `city` / `state` / `zip`, plus the CarGurus `reviewRating` and `reviewCount` pulled from the dealer's own storefront.
- 📦 **Business context on every dealer** — `inventoryCount` (cars live on their storefront), `brands[]` they sell, `franchiseMake`, `dealerType` (Franchise / Independent), `salesStatus` (paid/advertising signal), and `priceMin` / `priceMax` so you can segment by size, tier and buying intent.
- 🚘 **Sample inventory** — a `sampleListings[]` snapshot (year / make / model / trim / price / mileage / VIN / URL) for each dealer.
- 🔎 **Filter by make & condition** — scrape every dealer, or just the ones listing `Ford`, `Toyota`, `BMW`, etc., across Used, New, or both.
- 🇺🇸 **Built for the anti-bot** — runs on Apify US **residential** proxies with request pacing and automatic IP rotation, so pages come back populated, not challenged.

### 📊 Output — dealer + contact + rating + inventory in one flat record

Every dealer comes back as a flat JSON record. The fields that matter:

| Field | Type | Example |
|---|---|---|
| 🏢 `companyName` | text | `Lithia Chrysler Jeep Dodge Ram of Wasilla` |
| 📞 `phone` | text | `+1 737-353-5644` |
| 📍 `street` / `city` / `state` / `zip` | text | `2891 E Sun Mountain Ave` · `Wasilla` · `AK` · `99654` |
| ⭐ `reviewRating` / `reviewCount` | number | `3.67` / `3` |
| 🏷️ `franchiseMake` | text | `RAM` |
| 🧾 `dealerType` | text | `Franchise` |
| 📦 `inventoryCount` | number | `23` |
| 🚘 `brands` | array | `["Ford", "RAM", "Jeep"]` |
| 💵 `priceMin` / `priceMax` | number | `10990` / `54990` |
| 🔗 `dealerUrl` | link | `https://www.cargurus.com/Cars/m-d-sp347282` |

Plus `dealerId`, `serviceProviderId`, `salesStatus`, `logoUrl`, `countryCode`, `sampleListings[]` (year / make / model / trim / price / mileage / VIN / url), `source`, and `scrapedAt`.

<details><summary>🚗 Sample record</summary>

```json
{
  "source": "CarGurus",
  "dealerId": "1304570",
  "serviceProviderId": "347282",
  "companyName": "Lithia Chrysler Jeep Dodge Ram of Wasilla",
  "dealerType": "Franchise",
  "salesStatus": "PAYING",
  "phone": "+1 737-353-5644",
  "website": null,
  "reviewRating": 3.67,
  "reviewCount": 3,
  "franchiseMake": "RAM",
  "street": "2891 E Sun Mountain Ave",
  "city": "Wasilla",
  "state": "AK",
  "zip": "99654",
  "countryCode": "US",
  "inventoryCount": 23,
  "brands": ["Ford"],
  "priceMin": 10990,
  "priceMax": 10990,
  "sampleListings": [
    { "year": "2017", "make": "Ford", "model": "Escape", "trim": "SE AWD", "price": 10990, "mileage": 112086, "vin": "1FMCU9G91HUD20812", "url": "https://www.cargurus.com/Cars/link/453060023" }
  ],
  "dealerUrl": "https://www.cargurus.com/Cars/m-d-sp347282",
  "logoUrl": "https://static.cargurus.com/images/site/.../lithia...-200x200.jpeg",
  "scrapedAt": "2026-07-12T00:00:00.000Z"
}
````

</details>

> 💡 `reviewRating`, `reviewCount` and the full legal address come from the dealer's CarGurus storefront. CarGurus does not publish dealer emails; the direct **phone** and the dealer page are the contact path.

***

### Who it's for

- 🚀 **Automotive SaaS & DMS/CRM sales** — build territory lists of active dealers by make and franchise.
- 💳 **Dealer financing, insurance & warranty** targeting dealers with a live buying signal (open inventory) and a paid/advertising `salesStatus`.
- 🔧 **Parts, wholesale & remarketing** sourcing dealers by the brands and price tier they actually stock.
- 📈 **Market research** — dealer density, brand mix, rating distribution, and price bands across the US.
- 🔄 **CRM enrichment** — turn a make + condition into dealer-level contacts with phone, rating and inventory.

### How to use it

1. Click **Try for free**.
2. Pick a **Condition** (Used / New / Both) and, optionally, one or more **Makes** (e.g. `Ford`).
3. Set **Max dealers** and click **Start**.
4. Export from the **Dataset** tab (JSON, CSV, Excel, Google Sheets) or via API.

#### Examples

Ford dealers, used inventory:

```json
{ "condition": "Used", "makes": ["Ford"], "maxDealers": 100, "enrichDealer": true }
```

All dealers, listing-level only (faster, no rating/address step):

```json
{ "condition": "Both", "maxDealers": 200, "enrichDealer": false }
```

Luxury franchise dealers (multiple makes):

```json
{ "condition": "New", "makes": ["BMW", "Mercedes-Benz", "Audi"], "maxDealers": 50 }
```

***

### ❓ FAQ

**What contact details do I actually get?** Per dealer: company name, the direct phone shown on CarGurus, the full legal address (street, city, state, ZIP), the CarGurus star rating and review count, franchise make, dealer type, live inventory, the brands they stock and their price band.

**Why is it one row per dealer instead of per car?** Because you're prospecting dealers, not cars. The Actor dedupes by CarGurus seller id and aggregates each dealer's inventory (count, brands, price range, sample listings) onto a single lead.

**Do I get emails?** No — CarGurus does not expose dealer emails, so this Actor delivers the direct **phone**, address, rating and dealer page instead. (For emailed dealer leads, see our AutoScout24 dealer scraper for the European market.)

**Which market is covered?** The United States (cargurus.com).

**Do I need a login or API key?** No. It reads CarGurus' public dealer and listing data — no account, no key.

**Why residential proxies?** CarGurus fronts DataDome (velocity-based). The Actor defaults to Apify **US residential** with request pacing and IP rotation so pages return populated data.

**How is `inventoryCount` calculated?** It's the number of that dealer's live cars seen on their CarGurus storefront when enrichment is on; otherwise it falls back to the number of the dealer's cars seen during the run.

**How much does it cost?** Pay-per-result — you only pay for the dealers returned. It's free to try.

### Notes & fair use

You are responsible for complying with CarGurus' Terms of Service and all applicable laws, including **TCPA / CAN-SPAM** and state do-not-call rules when you contact dealers. This Actor reads publicly available business-directory data (the same dealer contact CarGurus shows on each dealer page). Use the contact data responsibly and keep a legitimate-interest basis for your outreach.

# Actor input Schema

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

Which CarGurus inventory to walk for dealers: Used, New, or Both.

## `makes` (type: `array`):

Optional. Restrict to dealers listing one or more makes, e.g. \["Ford", "Toyota", "BMW"]. Leave empty to scrape dealers across all makes.

## `maxDealers` (type: `integer`):

Cap on the number of unique dealers returned this run (cost/speed guard). Dealers are deduped by their CarGurus seller id. Default 100; set 0 to pull the whole scope (up to a safety cap).

## `enrichDealer` (type: `boolean`):

Fetch each dealer's CarGurus storefront to pull the star rating, review count, full legal street address and live inventory count. Turn off for a faster, listing-only pull (name, phone, city, state, ZIP).

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

Proxy settings. CarGurus fronts DataDome (velocity-based), so US RESIDENTIAL is the default and strongly recommended for reliable results.

## Actor input object example

```json
{
  "condition": "Used",
  "makes": [
    "Ford"
  ],
  "maxDealers": 3,
  "enrichDealer": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `records` (type: `string`):

The dataset of unique CarGurus car dealers (one item per dealer, with contact + rating + inventory).

# 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 = {
    "condition": "Used",
    "makes": [
        "Ford"
    ],
    "maxDealers": 3,
    "enrichDealer": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/cargurus-dealer-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 = {
    "condition": "Used",
    "makes": ["Ford"],
    "maxDealers": 3,
    "enrichDealer": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/cargurus-dealer-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 '{
  "condition": "Used",
  "makes": [
    "Ford"
  ],
  "maxDealers": 3,
  "enrichDealer": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call scrapersdelight/cargurus-dealer-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CarGurus Scraper — Car Dealer Leads with Phone & Ratings",
        "description": "Scrape US car dealers from CarGurus as clean B2B leads: dealer name, phone, full address, star rating, review count, franchise make, live inventory, brands sold and price range. One row per dealer (deduped). Filter by make and condition. No login.",
        "version": "0.1",
        "x-build-id": "yqAAObrXB6IWhW2LK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapersdelight~cargurus-dealer-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapersdelight-cargurus-dealer-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/scrapersdelight~cargurus-dealer-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapersdelight-cargurus-dealer-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/scrapersdelight~cargurus-dealer-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapersdelight-cargurus-dealer-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": {
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "Both",
                            "Used",
                            "New"
                        ],
                        "type": "string",
                        "description": "Which CarGurus inventory to walk for dealers: Used, New, or Both.",
                        "default": "Both"
                    },
                    "makes": {
                        "title": "Makes (optional filter)",
                        "type": "array",
                        "description": "Optional. Restrict to dealers listing one or more makes, e.g. [\"Ford\", \"Toyota\", \"BMW\"]. Leave empty to scrape dealers across all makes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxDealers": {
                        "title": "Max dealers",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on the number of unique dealers returned this run (cost/speed guard). Dealers are deduped by their CarGurus seller id. Default 100; set 0 to pull the whole scope (up to a safety cap).",
                        "default": 100
                    },
                    "enrichDealer": {
                        "title": "Enrich with rating, reviews & full address",
                        "type": "boolean",
                        "description": "Fetch each dealer's CarGurus storefront to pull the star rating, review count, full legal street address and live inventory count. Turn off for a faster, listing-only pull (name, phone, city, state, ZIP).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. CarGurus fronts DataDome (velocity-based), so US RESIDENTIAL is the default and strongly recommended for reliable results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```