# Autohero Scraper — Used Car Listings Across 9 EU Countries (`studio-amba/autohero-scraper`) Actor

Scrape used-car listings from Autohero.com (Auto1 Group) in Germany, France, Spain, Italy, Austria, Netherlands, Belgium, Poland, and Sweden. Get prices, mileage, year, fuel, gearbox, damage history, and optionally VIN, equipment, and service records. No login, no cookies. Export JSON, CSV, Excel.

- **URL**: https://apify.com/studio-amba/autohero-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 result scrapeds

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

## Autohero Scraper — Used Car Listings Across 9 EU Countries

Scrape used-car listings from [Autohero.com](https://www.autohero.com), the online used-car dealer of Auto1 Group. Autohero sells fully inspected cars from its own inventory in 9 European countries: Germany, France, Spain, Italy, Austria, the Netherlands, Belgium, Poland, and Sweden — roughly 20,000 cars at any time.

Every car comes with unusually deep data for a car site: documented accident and damage counts from Autohero's own inspection, previous-owner count, service-book status, and (with details enabled) the VIN, the full equipment list, and individual service-history records.

No login, no cookies, no API key. Export to JSON, CSV, Excel, or connect via the Apify API.

### What data you get

| Field | Description |
|---|---|
| `name`, `make`, `model`, `variant` | Full car identification, e.g. "Skoda Kodiaq 2.0 BiTDI RS 4x4" |
| `year` | First registration year |
| `mileage`, `mileageUnit` | Odometer reading in km |
| `price`, `currency` | Asking price in major units (EUR; PLN in Poland, SEK in Sweden) |
| `monthlyPayment` | Advertised financing rate per month |
| `fuelType`, `gearType`, `driveTrain` | petrol/diesel/electric/hybrid…, manual/automatic, front/rear/all-wheel |
| `powerKw`, `powerHp`, `engineCcm` | Engine power and displacement |
| `co2`, `consumptionCombined/City/Highway` | Emissions and fuel consumption |
| `previousOwners` | Number of previous owners |
| `accidentCount`, `damageCount` | Recorded accidents and documented cosmetic damages |
| `hasServiceBook`, `lastServiceOn` | Service-book status and last service date |
| `branchLocation` | Autohero branch where the car is stocked |
| `imageUrl` | Main photo in full resolution |
| `url` | Direct link to the car page |
| `vin` | Vehicle identification number (with `fetchDetails`) |
| `equipment` | Equipment list, first 30 items (with `fetchDetails`) |
| `serviceHistory` | Service records: date, mileage, type (with `fetchDetails`) |

### How to scrape Autohero data

1. Pick a **country** (Germany has the largest inventory, ~7,500 cars).
2. Optionally filter by **make** ("BMW", "Volkswagen", "Mercedes-Benz" — aliases like "VW" work), **model** ("X1", "Golf", "Clio"), **maxPrice**, **minYear**, **maxMileage**, **fuelType**, or **gearType**.
3. Set **maxResults** (default 100). Leave all filters empty to scrape the whole country catalogue.
4. Optionally enable **fetchDetails** to add VIN, equipment, service history, and image counts. This costs one extra request per car, so a full-country detail run takes noticeably longer.
5. Run the actor and export the dataset in the format you need.

The scraper talks to Autohero's own product API, so results match exactly what the website shows, including prices and availability.

#### Example input

```json
{
  "country": "de",
  "make": "BMW",
  "maxPrice": 30000,
  "minYear": 2019,
  "fuelType": "diesel",
  "maxResults": 100,
  "proxyConfiguration": { "useApifyProxy": true }
}
````

#### Example output

```json
{
  "id": "5f7daa61-c635-4615-be9c-22aa3fa56c90",
  "name": "Skoda Kodiaq 2.0 BiTDI RS 4x4",
  "make": "Skoda",
  "model": "Kodiaq",
  "variant": "2.0 BiTDI RS 4x4",
  "year": 2019,
  "mileage": 88312,
  "mileageUnit": "km",
  "price": 29390,
  "currency": "EUR",
  "monthlyPayment": 404,
  "fuelType": "diesel",
  "gearType": "automatic",
  "driveTrain": "all-wheel-drive",
  "powerKw": 176,
  "powerHp": 239,
  "engineCcm": 1968,
  "co2": 167,
  "consumptionCombined": 6.4,
  "previousOwners": 1,
  "accidentCount": 0,
  "damageCount": 24,
  "hasServiceBook": false,
  "lastServiceOn": "2025-12-09",
  "branchLocation": "Workshop Ketzin, Ketzin, 14669",
  "imageUrl": "https://img-eu-c1.autohero.com/img/97e92dcb…/exterior/1/70cab346c7b04cf39f2f877f6465f689.jpg",
  "url": "https://www.autohero.com/de/skoda-kodiaq/id/5f7daa61-c635-4615-be9c-22aa3fa56c90/",
  "country": "de",
  "scrapedAt": "2026-07-11T19:04:12.345Z"
}
```

### Countries and inventory size

| Country | Store | Approx. cars |
|---|---|---|
| Germany | `de` | 7,400 |
| France | `fr` | 3,200 |
| Italy | `it` | 3,100 |
| Spain | `es` | 2,500 |
| Belgium | `be` | 1,300 |
| Poland | `pl` | 800 |
| Austria | `at` | 750 |
| Netherlands | `nl` | 430 |
| Sweden | `se` | 400 |

A full-country listing scrape finishes in a few minutes. Prices are returned in the local currency: EUR everywhere except Poland (PLN) and Sweden (SEK).

### Use cases

- **Price monitoring** — track asking prices for specific makes and models across countries, spot cross-border price gaps for the same car class.
- **Market research** — analyse the EU used-car market: which models dominate, how mileage and age affect pricing, EV vs combustion share per country.
- **Vehicle sourcing** — dealers and exporters can filter by price, year, mileage, and damage count, and get the VIN and full equipment list for shortlisted cars.
- **Data products** — feed clean, structured car data into valuation models, comparison sites, or alerting tools.

### FAQ

#### Is scraping Autohero legal?

The actor collects only publicly available product listings — the same data any visitor sees in a browser. It collects no personal data. Review Autohero's terms of service and consult a lawyer if you plan large-scale commercial use.

#### How fresh is the data?

Every run queries Autohero's live product API in real time. Prices, availability, and damage data are current as of the moment the run finishes.

#### Why are some cars marked with damages if Autohero sells inspected cars?

Autohero documents every cosmetic flaw (scratches, dents, stone chips) during inspection. A `damageCount` of 20 usually means 20 photographed minor blemishes, not a wreck — `accidentCount` is the field that tracks real accident history.

#### What does fetchDetails cost?

One extra API request per car. For 100 cars the difference is seconds; for a full German catalogue (~7,500 cars) it turns a 2-minute run into a run of an hour or more. The actor persists progress across platform migrations, so long detail runs resume instead of restarting.

#### Can I scrape all countries in one run?

One run scrapes one country store. To cover all 9, start 9 runs (they are cheap and fast) — or schedule them. Each country has its own separate inventory, so there is no overlap between runs.

### Related scrapers

More car-market scrapers from the same developer:

- [AutoTrader UK Scraper](https://apify.com/store?search=autotrader-uk-scraper) — UK's largest car marketplace
- [Car.gr Scraper](https://apify.com/store?search=car-gr-scraper) — Greek car classifieds
- [Polovni Automobili Scraper](https://apify.com/store?search=polovni-automobili-scraper) — Serbia's biggest car site
- [Hasznaltauto Scraper](https://apify.com/store?search=hasznaltauto-scraper) — Hungary's used-car marketplace
- [Mobile.bg Scraper](https://apify.com/store?search=mobile-bg-scraper) — Bulgaria's leading car classifieds

### Support

Found a bug or need an extra field? Open an issue on the actor's Issues tab and it will be looked at quickly.

# Actor input Schema

## `country` (type: `string`):

Autohero country store to scrape. Each country has its own inventory (Germany is the largest with ~7,500 cars).

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

Filter by car make, e.g. 'BMW', 'Volkswagen', 'Mercedes-Benz', 'Renault'. Case-insensitive; common aliases like 'VW' or 'Mercedes' work too. Leave empty for all makes.

## `model` (type: `string`):

Filter by model name as Autohero lists it, e.g. 'X1', 'Golf', 'C-Klasse', 'Clio'. Case-insensitive exact match. Leave empty for all models.

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

Maximum price in the country's currency (EUR; PLN in Poland, SEK in Sweden). Example: 15000.

## `minYear` (type: `integer`):

Minimum first-registration year, e.g. 2020.

## `maxMileage` (type: `integer`):

Maximum mileage in kilometres, e.g. 50000.

## `fuelType` (type: `string`):

Filter by fuel type. Leave empty for all.

## `gearType` (type: `string`):

Filter by gearbox type. Leave empty for all.

## `fetchDetails` (type: `boolean`):

Enrich each car with its VIN, full equipment list (first 30 items), service-history records, and total image count. Costs one extra request per car: 100 cars is quick, but a full country catalogue means thousands of extra requests and a much longer run. Leave off for fast listing scrapes.

## `maxResults` (type: `integer`):

Maximum number of cars to return. The full EU inventory is roughly 20,000 cars; Germany alone is ~7,500.

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

Proxy settings. The Autohero API is public and open, so default Apify proxies work well.

## Actor input object example

```json
{
  "country": "de",
  "make": "BMW",
  "fetchDetails": false,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "country": "de",
    "make": "BMW",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/autohero-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 = {
    "country": "de",
    "make": "BMW",
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/autohero-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 '{
  "country": "de",
  "make": "BMW",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/autohero-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Autohero Scraper — Used Car Listings Across 9 EU Countries",
        "description": "Scrape used-car listings from Autohero.com (Auto1 Group) in Germany, France, Spain, Italy, Austria, Netherlands, Belgium, Poland, and Sweden. Get prices, mileage, year, fuel, gearbox, damage history, and optionally VIN, equipment, and service records. No login, no cookies. Export JSON, CSV, Excel.",
        "version": "0.1",
        "x-build-id": "BR8be7PDbdWbG0YtR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~autohero-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-autohero-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/studio-amba~autohero-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-autohero-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/studio-amba~autohero-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-autohero-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": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "de",
                            "fr",
                            "es",
                            "it",
                            "at",
                            "nl",
                            "be",
                            "pl",
                            "se"
                        ],
                        "type": "string",
                        "description": "Autohero country store to scrape. Each country has its own inventory (Germany is the largest with ~7,500 cars).",
                        "default": "de"
                    },
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Filter by car make, e.g. 'BMW', 'Volkswagen', 'Mercedes-Benz', 'Renault'. Case-insensitive; common aliases like 'VW' or 'Mercedes' work too. Leave empty for all makes."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Filter by model name as Autohero lists it, e.g. 'X1', 'Golf', 'C-Klasse', 'Clio'. Case-insensitive exact match. Leave empty for all models."
                    },
                    "maxPrice": {
                        "title": "Max Price",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum price in the country's currency (EUR; PLN in Poland, SEK in Sweden). Example: 15000."
                    },
                    "minYear": {
                        "title": "Min Year",
                        "minimum": 1990,
                        "type": "integer",
                        "description": "Minimum first-registration year, e.g. 2020."
                    },
                    "maxMileage": {
                        "title": "Max Mileage (km)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum mileage in kilometres, e.g. 50000."
                    },
                    "fuelType": {
                        "title": "Fuel Type",
                        "enum": [
                            "petrol",
                            "diesel",
                            "electric",
                            "hybrid",
                            "lpg",
                            "cng",
                            "hydrogen",
                            "ethanol",
                            "other"
                        ],
                        "type": "string",
                        "description": "Filter by fuel type. Leave empty for all."
                    },
                    "gearType": {
                        "title": "Gearbox",
                        "enum": [
                            "manual",
                            "automatic",
                            "semi-automatic"
                        ],
                        "type": "string",
                        "description": "Filter by gearbox type. Leave empty for all."
                    },
                    "fetchDetails": {
                        "title": "Fetch Details (VIN, equipment, service history)",
                        "type": "boolean",
                        "description": "Enrich each car with its VIN, full equipment list (first 30 items), service-history records, and total image count. Costs one extra request per car: 100 cars is quick, but a full country catalogue means thousands of extra requests and a much longer run. Leave off for fast listing scrapes.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum number of cars to return. The full EU inventory is roughly 20,000 cars; Germany alone is ~7,500.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. The Autohero API is public and open, so default Apify proxies work well."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
