# RockAuto Parts Catalog Scraper (`automation-lab/rockauto-parts-catalog-scraper`) Actor

🚗 Extract RockAuto auto parts listings with fitment, manufacturer part numbers, prices, core charges, stock signals, and more-info URLs.

- **URL**: https://apify.com/automation-lab/rockauto-parts-catalog-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

## RockAuto Parts Catalog Scraper

Extract RockAuto auto parts catalog listings with vehicle fitment, manufacturer part numbers, prices, core charges, availability signals, and more-info URLs.

Use this RockAuto scraper when you need repeatable catalog data for pricing, market monitoring, ecommerce enrichment, repair-shop sourcing, or automotive parts research.

### What does RockAuto Parts Catalog Scraper do?

RockAuto Parts Catalog Scraper reads public RockAuto catalog pages and saves structured product listing rows to an Apify dataset.

It works with RockAuto vehicle, category, and part-type URLs.

For product listing pages, it extracts the listing table directly.

For category pages, it discovers part-type pages and follows them until your item and page limits are reached.

### Who is it for?

Auto parts sellers use it to monitor competitor prices and part availability.

Repair shops use it to compare aftermarket options for known vehicle fitments.

Ecommerce teams use it to enrich SKU catalogs with manufacturer part numbers and descriptions.

Market analysts use it to track price bands, closeout categories, and brand coverage.

Developers use it to feed RockAuto listing data into CRMs, databases, alerts, and repricing pipelines.

### Why use this actor?

- 🚗 Extract vehicle fitment context from RockAuto catalog URLs.
- 🔩 Capture manufacturer names and part numbers.
- 💵 Save visible price and core charge text.
- 📦 Include stock/availability signals where RockAuto exposes them in HTML.
- 🔗 Keep the source URL and more-info URL for traceability.
- ⚙️ Run in the cloud, on a schedule, or through the Apify API.

### What data can you extract?

The dataset includes product listing fields from RockAuto catalog pages.

| Field | Description |
| --- | --- |
| `vehicle` | Parsed year, make, model, and engine |
| `category` | RockAuto category, such as Brake & Wheel Hub |
| `partType` | Part type, such as Brake Pad |
| `manufacturer` | Listing manufacturer or catalog brand |
| `partNumber` | Manufacturer part number shown by RockAuto |
| `description` | Listing description, material, or kit notes |
| `notes` | Fitment notes and position text |
| `priceText` | Visible price text |
| `coreChargeText` | Visible core charge text |
| `availability` | Basic availability signal |
| `sortGroup` | RockAuto sort group such as Economy or Daily Driver |
| `moreInfoUrl` | RockAuto more-info URL |
| `sourceUrl` | Catalog page that produced the record |

### How much does it cost to scrape RockAuto parts?

This actor uses pay-per-event pricing with two charge events:

| Charge event | Price |
| --- | ---: |
| Run started | $0.005 per run |
| Item extracted, FREE tier | $0.000032519 per saved part listing |
| Item extracted, BRONZE tier | $0.000028277 per saved part listing |
| Item extracted, SILVER tier | $0.000022056 per saved part listing |
| Item extracted, GOLD tier | $0.000016966 per saved part listing |
| Item extracted, PLATINUM tier | $0.000011311 per saved part listing |
| Item extracted, DIAMOND tier | $0.000010000 per saved part listing |

Example FREE-tier run costs before Apify platform usage fees: about $0.0083 for 100 listings, $0.0375 for 1,000 listings, and $0.3302 for 10,000 listings.

A new Apify Free plan with $5 in platform credits can run roughly 153,000 FREE-tier item charges after one start charge if no other Apify usage consumes the credits.

Use smaller `maxItems` values for quick checks.

Use larger limits for monitoring or repricing datasets.

### Input

The main input is `startUrls`.

Add one or more RockAuto catalog URLs.

Recommended URLs look like:

```json
{
  "startUrls": [
    { "url": "https://www.rockauto.com/en/catalog/toyota,2010,corolla,1.8l+l4,1444173,brake+&+wheel+hub" }
  ],
  "maxItems": 100,
  "maxPages": 25
}
````

### Input fields

`startUrls` is required.

It accepts RockAuto vehicle, category, or part-type catalog pages.

`maxItems` controls the maximum number of product listing records saved.

`maxPages` controls how many catalog pages can be fetched while discovering part-type listing pages.

### Output example

```json
{
  "vehicle": "2010 toyota corolla 1.8l l4",
  "category": "brake & wheel hub",
  "partType": "brake pad",
  "manufacturer": "CENTRIC",
  "partNumber": "10215720",
  "description": "C-TEK; Semi-Metallic",
  "notes": "Rear",
  "priceText": "€13.26",
  "coreChargeText": "€0.00",
  "availability": "available",
  "moreInfoUrl": "https://www.rockauto.com/en/moreinfo.php?pk=4388967&cc=1444173&pt=1684"
}
```

### How to use it

1. Open RockAuto and navigate to a vehicle or category page.

2. Copy the catalog URL from your browser.

3. Paste it into `startUrls`.

4. Set `maxItems` to the volume you need.

5. Run the actor.

6. Export the dataset as JSON, CSV, Excel, XML, or HTML.

### Tips for best results

Use category or part-type pages instead of the homepage.

Start with one vehicle/category URL while testing.

Increase `maxPages` when starting from broad category pages.

Use schedules to monitor the same fitments over time.

Compare `partNumber`, `manufacturer`, and `priceText` across runs for changes.

### Integrations

Send dataset rows to Google Sheets for pricing review.

Push records to a warehouse for historical price tracking.

Trigger webhooks when a scheduled run finishes.

Use Make, Zapier, or Apify integrations to notify purchasing teams.

Join output with internal SKU catalogs by manufacturer and part number.

### 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/rockauto-parts-catalog-scraper').call({
  startUrls: [{ url: 'https://www.rockauto.com/en/catalog/toyota,2010,corolla,1.8l+l4,1444173,brake+&+wheel+hub' }],
  maxItems: 100,
  maxPages: 25,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/rockauto-parts-catalog-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.rockauto.com/en/catalog/toyota,2010,corolla,1.8l+l4,1444173,brake+&+wheel+hub'}],
    'maxItems': 100,
    'maxPages': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~rockauto-parts-catalog-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.rockauto.com/en/catalog/toyota,2010,corolla,1.8l+l4,1444173,brake+&+wheel+hub"}],"maxItems":100,"maxPages":25}'
```

### MCP usage

Use Apify MCP to call this actor from Claude Desktop, Claude Code, or other MCP-compatible tools.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/rockauto-parts-catalog-scraper
```

Claude Code setup:

```bash
claude mcp add apify-rockauto --transport http "https://mcp.apify.com/?tools=automation-lab/rockauto-parts-catalog-scraper"
```

JSON MCP server setup:

```json
{
  "mcpServers": {
    "apify-rockauto": {
      "url": "https://mcp.apify.com/?tools=automation-lab/rockauto-parts-catalog-scraper"
    }
  }
}
```

Example prompt:

```text
Run the RockAuto Parts Catalog Scraper for this Corolla brake category and summarize the cheapest available brake pad listings.
```

### Common workflows

Monitor brake pads for a repair-shop buying list.

Track closeout or economy part options by vehicle.

Build a fitment-aware SKU enrichment table.

Compare aftermarket manufacturer coverage across categories.

Create weekly alerts for price changes on selected part types.

### Limitations

RockAuto page structure can change.

The actor extracts public catalog HTML; it does not place orders or access accounts.

Some prices and availability signals can vary by location, cookies, or RockAuto market settings.

Very broad inputs may need higher page limits.

The actor does not guarantee complete catalog coverage for every vehicle unless your limits allow enough pages.

### Troubleshooting

If the actor returns no items, use a more specific RockAuto catalog URL.

If it stops early, increase `maxItems` and `maxPages`.

If prices appear in a different currency, check RockAuto market/cookie behavior for the session.

If a URL has special characters, paste the full browser URL; the actor normalizes it during requests.

### Data freshness

Each row includes `scrapedAt`.

Use this timestamp when comparing scheduled runs.

RockAuto can update listings, prices, availability, and warehouse options at any time.

### Legality

This actor extracts publicly available catalog pages.

You are responsible for using the output lawfully and respecting RockAuto terms, robots guidance, and applicable regulations.

Do not use scraped data for prohibited or abusive purposes.

### Related scrapers

Explore related Automation Labs actors for ecommerce, marketplace, vehicle, and lead-generation workflows.

Useful neighbors include product catalog scrapers, marketplace listing scrapers, and business data extractors under `https://apify.com/automation-lab/`.

### Support

If a run fails, inspect the log and the input URL first.

Share the run URL and a short description of the expected catalog page when reporting an issue.

### Changelog

Initial version extracts RockAuto product listing rows from public catalog pages.

### FAQ

Can I scrape multiple RockAuto URLs in one run?

Yes. Add multiple objects to `startUrls`.

Can I scrape from a broad category page?

Yes. The actor discovers part-type pages from category navigation.

Can I scrape the whole RockAuto catalog?

Use bounded batches by vehicle/category. Full-catalog crawling can be large and should be split into scheduled runs.

Does it use a browser?

No. The current implementation is HTTP-first with Cheerio because RockAuto exposes the needed listing HTML in the initial response.

Does it return shipping cost?

No. It returns listing-level catalog data, not cart checkout calculations.

# Actor input Schema

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

RockAuto catalog or part-listing URLs. Product listing pages are best; category pages are followed to part-type pages until the limits are reached.

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

Maximum number of RockAuto product listing records to save.

## `maxPages` (type: `integer`):

Maximum number of catalog/category/part-type pages to request while discovering listings.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.rockauto.com/en/catalog/toyota,2010,corolla,1.8l+l4,1444173,brake+&+wheel+hub"
    }
  ],
  "maxItems": 20,
  "maxPages": 20
}
```

# 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://www.rockauto.com/en/catalog/toyota,2010,corolla,1.8l+l4,1444173,brake+&+wheel+hub"
        }
    ],
    "maxItems": 20,
    "maxPages": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/rockauto-parts-catalog-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://www.rockauto.com/en/catalog/toyota,2010,corolla,1.8l+l4,1444173,brake+&+wheel+hub" }],
    "maxItems": 20,
    "maxPages": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/rockauto-parts-catalog-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://www.rockauto.com/en/catalog/toyota,2010,corolla,1.8l+l4,1444173,brake+&+wheel+hub"
    }
  ],
  "maxItems": 20,
  "maxPages": 20
}' |
apify call automation-lab/rockauto-parts-catalog-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RockAuto Parts Catalog Scraper",
        "description": "🚗 Extract RockAuto auto parts listings with fitment, manufacturer part numbers, prices, core charges, stock signals, and more-info URLs.",
        "version": "0.1",
        "x-build-id": "gBfbinuDytWrQoTfd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~rockauto-parts-catalog-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-rockauto-parts-catalog-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~rockauto-parts-catalog-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-rockauto-parts-catalog-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~rockauto-parts-catalog-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-rockauto-parts-catalog-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "RockAuto catalog or part-listing URLs. Product listing pages are best; category pages are followed to part-type pages until the limits are reached.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum product listings",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of RockAuto product listing records to save.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum pages to fetch",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of catalog/category/part-type pages to request while discovering listings.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```