# Skoda Stock & Pricing Scraper (`rastriq/skoda-stock-pricing`) Actor

Extract vehicle stock, pricing, specs, financing and dealer data from Skoda VTP across 11 markets. No API key needed. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/rastriq/skoda-stock-pricing.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.

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

## Skoda Stock & Pricing Scraper

Extract real-time vehicle stock, pricing, specs, financing, and dealer data from Skoda's official inventory across 11 European and international markets. **Skoda Stock & Pricing Scraper** gives you structured data on every new Skoda available for sale — no API key, no login required.

> Try it free — your first $5 of usage is on Apify. No credit card required.


### What is Skoda Stock & Pricing Scraper?

**Skoda Stock & Pricing Scraper** is an unofficial Skoda inventory API that extracts complete vehicle listings from Skoda's official website. It covers all model lines — Fabia, Scala, Octavia, Superb, Kamiq, Karoq, Kodiaq, Enyaq, Elroq, and Epiq — across multiple countries simultaneously.

Use Skoda Stock & Pricing Scraper to:

- **Monitor dealer stock and availability** — track which models, trims, and colors are in stock across markets
- **Compare pricing across countries** — identify price differences for the same model between Finland, Spain, Poland, and 8 other markets
- **Analyze financing offers** — extract monthly payment, TAE, TIN, and full financing breakdowns where available
- **Track market trends** — schedule daily runs to monitor how stock levels and pricing evolve over time

The Apify platform adds **scheduling**, **monitoring**, **API access**, **proxy rotation**, and **integrations** with Make, Zapier, Google Sheets, and more — all out of the box.


### What data does Skoda Stock & Pricing Scraper extract?

Each vehicle record includes 40+ structured fields:

|                          |                                    |
| ------------------------ | ---------------------------------- |
| **Vehicle identity** — VIN, commission number, model, trim, body type, model year | **Engine & drivetrain** — engine name, power (kW), displacement, fuel type, transmission, drive |
| **Pricing** — list price, sale price, option price, color price, omnibus price, additional taxes | **Financing** — monthly payment, TAE, TIN, full breakdown (where available) |
| **Colors** — exterior color name + code, interior color name + code | **Dealer** — name, city, address, GPS coordinates, phone, email, website |
| **Emissions** — WLTP CO2 and fuel consumption (city, highway, combined) | **Images** — up to 8 high-resolution exterior and interior renders |
| **Availability** — available from date, production date, demo/reserved/importer flags | **Metadata** — business model, carline, MBV code, scraping timestamp |

> Fields marked as optional may not appear in all markets depending on the importer configuration.


### How to use Skoda Stock & Pricing Scraper

Extracting Skoda vehicle data takes under two minutes:

1. **Create a free Apify account** at [apify.com](https://apify.com) — your first $5 is free
2. **Open Skoda Stock & Pricing Scraper** in Apify Console or click **Try for free** on this page
3. **Select markets** — pick one or more countries from the dropdown, or leave empty to scrape all 11 markets
4. **Configure output options** — toggle dealer info, financing details, and WLTP emissions on or off
5. **Click Save & Start** — the scraper is fast and lightweight, results arrive in seconds
6. **Download your results** in JSON, CSV, Excel, or XML — or access them via API


### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `countries` | array | No | All markets | Select specific countries to scrape (FIN, ESP, NLD, POL, DNK, SVK, BGR, SRB, ARE, MIE, UKR) |
| `maxPagesPerCountry` | integer | No | 0 (unlimited) | Max pages per country (100 cars/page). Use a low value for testing |
| `includeDealer` | boolean | No | `true` | Include dealer name, address, GPS, and contact info |
| `includeFinancing` | boolean | No | `true` | Include monthly payment and financing breakdown |
| `includeEmissions` | boolean | No | `true` | Include WLTP CO2 and fuel consumption data |
| `proxyConfiguration` | object | No | — | Optional proxy config. The API works without proxy from most locations |

**Example input:**

```json
{
  "countries": ["ESP", "FIN", "POL"],
  "maxPagesPerCountry": 5,
  "includeDealer": true,
  "includeFinancing": true,
  "includeEmissions": false
}
````

### Output example

Each result is a structured JSON object. Here's a sample from a real run:

```json
{
  "id": "FIN50314509167",
  "vin": "TMBEP6PJ4V4025440",
  "commissionNumber": "509167",
  "countryCode": "FIN",
  "market": "Finland",
  "brand": "Skoda",
  "marketingName": "Fabia",
  "title": "Explore",
  "bodywork": "Hatchback",
  "modelYear": 2027,
  "engineShortName": "1.0 TSI 95",
  "powerKw": 70,
  "fuelCode": "Petrol",
  "transmission": "Manual",
  "salePrice": {
    "value": 20408.76,
    "currency": "EUR",
    "label": "Hinta"
  },
  "exteriorColor": "Candy White",
  "dealer": {
    "name": "Rinta-Joupin Autoliike Pori",
    "city": "Pori",
    "latitude": 61.49873,
    "longitude": 21.80082
  },
  "financing": null,
  "availableFrom": "Immediately",
  "scrapedAt": "2026-07-03T09:52:24.494650+00:00"
}
```

Download results in **JSON, CSV, Excel, XML, or HTML** from the Output tab, or pull them programmatically using the Apify API (see the API tab for ready-to-use code snippets).

### How much does it cost to use Skoda Stock & Pricing Scraper?

**Skoda Stock & Pricing Scraper** runs on Apify's standard Compute Unit (CU) pricing. The scraper is extremely efficient:

- A **full run across all 11 markets** (~13,000 vehicles) consumes approximately **0.05 CUs** (~$0.025)
- A **single-country run** (e.g., Spain ~3,500 vehicles) completes in under a minute

Is scraping Skoda stock data free? Your first $5 of usage is covered by Apify's free plan credit — enough for hundreds of full scraping runs at no cost.

> **Tip**: Start with a single country and `maxPagesPerCountry: 2` to validate the output before scaling.

### Covered markets

| Code | Country | Locale | Typical stock |
|------|---------|--------|---------------|
| FIN | Finland | fi-fi | ~1,800 vehicles |
| ESP | Spain | es-es | ~3,500 vehicles |
| NLD | Netherlands | nl-nl | ~1,200 vehicles |
| POL | Poland | pl-pl | ~2,500 vehicles |
| SVK | Slovakia | sk-sk | ~1,500 vehicles |
| BGR | Bulgaria | bg-bg | ~800 vehicles |
| SRB | Serbia | sr-rs | ~600 vehicles |
| UKR | Ukraine | uk-ua | ~1,000 vehicles |
| ARE | UAE | en-ae | ~200 vehicles |
| DNK | Denmark | da-dk | Variable |
| MIE | Middle East | en-gb | Variable |

### Frequently Asked Questions

#### Is scraping Skoda vehicle data legal?

Skoda Stock & Pricing Scraper only accesses **publicly available data** on Skoda's official website — the same vehicle listings visible to any visitor browsing the Skoda online configurator. No personal data is collected. As with any data collection activity, you are responsible for ensuring your use case complies with applicable laws and Skoda's Terms of Service. For guidance, see [Apify's blog on the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

#### Does Skoda Stock & Pricing Scraper require a Skoda account or API key?

No. The scraper works entirely with public data from Skoda's official website and does not require any account, login, or API credentials.

#### How many vehicles can I extract?

The scraper extracts **all available stock** in each selected market — typically 10,000–15,000 vehicles across all 11 markets combined. There is no artificial limit.

#### What proxy configuration should I use?

The scraper works without proxy from most locations. If you experience issues, enable Apify's datacenter proxies in the input configuration.

#### How do I integrate the data with my workflow?

Skoda Stock & Pricing Scraper integrates natively with **Make**, **Zapier**, **Google Sheets**, **webhooks**, and the **Apify API**. Schedule daily runs to keep your dataset fresh and receive notifications when new data is available.

#### I found a bug or my run failed. Where do I report it?

Please open an issue in the **Issues tab** on this page. Include your input configuration and the run ID so we can investigate quickly.

# Actor input Schema

## `countries` (type: `array`):

Select one or more markets to scrape. Each country returns <b>local pricing</b> in its native currency.<br><br>Leave empty to scrape <b>all available markets</b> (~13,000 vehicles).<br><br>💡 <b>Tip:</b> Start with 1–2 countries for a quick test run.

## `maxPagesPerCountry` (type: `integer`):

Each page returns <b>100 vehicles</b>. Set to <code>0</code> for unlimited.<br><br>Recommended:<br>• <b>1–2 pages</b> — quick test<br>• <b>0 (unlimited)</b> — full extraction

## `includeDealer` (type: `boolean`):

Adds dealer <b>name, address, GPS coordinates, phone, email</b> and website for each vehicle.<br><br>Useful for mapping dealer networks or finding nearby stock.

## `includeFinancing` (type: `boolean`):

Adds <b>monthly payment, TAE, TIN</b> and full financing breakdown where available.<br><br>⚠️ Not all markets provide financing data. Spain (🇪🇸) has the richest financing info.

## `includeEmissions` (type: `boolean`):

Adds detailed <b>WLTP CO₂ emissions</b> and <b>fuel consumption</b> values (city, highway, combined).<br><br>Useful for fleet management and environmental compliance.

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

Optional. The scraper works <b>without proxies</b> from most locations. Only enable if you experience blocking.

## Actor input object example

```json
{
  "countries": [],
  "maxPagesPerCountry": 2,
  "includeDealer": true,
  "includeFinancing": true,
  "includeEmissions": true
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing all extracted vehicles with pricing, specs, dealer info, financing details and emissions data.

# 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 = {
    "maxPagesPerCountry": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/skoda-stock-pricing").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 = { "maxPagesPerCountry": 2 }

# Run the Actor and wait for it to finish
run = client.actor("rastriq/skoda-stock-pricing").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 '{
  "maxPagesPerCountry": 2
}' |
apify call rastriq/skoda-stock-pricing --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skoda Stock & Pricing Scraper",
        "description": "Extract vehicle stock, pricing, specs, financing and dealer data from Skoda VTP across 11 markets. No API key needed. Export to JSON, CSV or Excel.",
        "version": "0.1",
        "x-build-id": "GLQr0rY5Ddnk2ru3Q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rastriq~skoda-stock-pricing/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rastriq-skoda-stock-pricing",
                "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/rastriq~skoda-stock-pricing/runs": {
            "post": {
                "operationId": "runs-sync-rastriq-skoda-stock-pricing",
                "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/rastriq~skoda-stock-pricing/run-sync": {
            "post": {
                "operationId": "run-sync-rastriq-skoda-stock-pricing",
                "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": {
                    "countries": {
                        "title": "🌍 Countries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select one or more markets to scrape. Each country returns <b>local pricing</b> in its native currency.<br><br>Leave empty to scrape <b>all available markets</b> (~13,000 vehicles).<br><br>💡 <b>Tip:</b> Start with 1–2 countries for a quick test run.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "FIN",
                                "ESP",
                                "NLD",
                                "POL",
                                "DNK",
                                "SVK",
                                "BGR",
                                "SRB",
                                "ARE",
                                "MIE",
                                "UKR"
                            ],
                            "enumTitles": [
                                "🇫🇮 Finland (EUR)",
                                "🇪🇸 Spain (EUR)",
                                "🇳🇱 Netherlands (EUR)",
                                "🇵🇱 Poland (PLN)",
                                "🇩🇰 Denmark (DKK)",
                                "🇸🇰 Slovakia (EUR)",
                                "🇧🇬 Bulgaria (BGN)",
                                "🇷🇸 Serbia (RSD)",
                                "🇦🇪 UAE (AED)",
                                "🌍 Middle East (USD)",
                                "🇺🇦 Ukraine (UAH)"
                            ]
                        },
                        "default": []
                    },
                    "maxPagesPerCountry": {
                        "title": "📄 Max pages per country",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Each page returns <b>100 vehicles</b>. Set to <code>0</code> for unlimited.<br><br>Recommended:<br>• <b>1–2 pages</b> — quick test<br>• <b>0 (unlimited)</b> — full extraction",
                        "default": 0
                    },
                    "includeDealer": {
                        "title": "🏢 Include dealer info",
                        "type": "boolean",
                        "description": "Adds dealer <b>name, address, GPS coordinates, phone, email</b> and website for each vehicle.<br><br>Useful for mapping dealer networks or finding nearby stock.",
                        "default": true
                    },
                    "includeFinancing": {
                        "title": "💰 Include financing details",
                        "type": "boolean",
                        "description": "Adds <b>monthly payment, TAE, TIN</b> and full financing breakdown where available.<br><br>⚠️ Not all markets provide financing data. Spain (🇪🇸) has the richest financing info.",
                        "default": true
                    },
                    "includeEmissions": {
                        "title": "🌿 Include WLTP emissions",
                        "type": "boolean",
                        "description": "Adds detailed <b>WLTP CO₂ emissions</b> and <b>fuel consumption</b> values (city, highway, combined).<br><br>Useful for fleet management and environmental compliance.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy configuration",
                        "type": "object",
                        "description": "Optional. The scraper works <b>without proxies</b> from most locations. Only enable if you experience blocking."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
