# Autodoc Scraper — Car Parts with OEM Numbers & EAN (`studio-amba/autodoc-scraper`) Actor

Scrape car parts from autodoc.de: names, brands, prices, OEM cross-reference numbers, EAN codes, manufacturer part numbers, vehicle compatibility, specs, ratings, and stock. Crawls the category tree and product pages. Works across Autodoc's EU storefronts (.de, .co.uk, .fr, .es, .it and more).

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

## Pricing

from $8.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 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

## Autodoc Scraper — Car Parts with OEM Numbers & EAN

Scrape car parts from Autodoc, Europe's largest online car-parts retailer: names, brands, prices, OEM cross-reference numbers, EAN barcodes, manufacturer part numbers, technical specs, ratings, and vehicle compatibility.

### What is Autodoc Scraper?

Autodoc sells millions of car parts across roughly 27 European storefronts (autodoc.de, autodoc.co.uk, autodoc.fr, autodoc.es, autodoc.it, autodoc.nl, and more) that all run on the same platform. Its product pages carry the data that matters in the automotive aftermarket: the OEM cross-reference numbers that map an aftermarket part to the original equipment numbers of VW, BMW, Mercedes and every other vehicle maker, plus EAN barcodes, manufacturer part numbers, and full spec tables.

This actor crawls Autodoc's category tree, harvests product links, and extracts the complete data set from each product page. One `domain` input switches the same actor between country storefronts.

- **Part cross-referencing** — Map aftermarket parts (Bosch, Brembo, ATE, Febi, ...) to OEM numbers per vehicle manufacturer
- **Price monitoring** — Track aftermarket part prices across European markets and against your own catalog
- **Catalog enrichment** — Pull EAN codes, part numbers, and spec tables to enrich a parts database or marketplace listing
- **Assortment analysis** — See which brands and product lines Autodoc pushes per category
- **Cross-country comparison** — Run the same category on .de, .fr, and .co.uk to compare pricing per market

### What data does Autodoc Scraper extract?

- **Product name** — Full title including brand and part number
- **Brand** — Parts manufacturer (BOSCH, BREMBO, ATE, ZIMMERMANN, TEXTAR, ...)
- **Price & currency** — Current price in the storefront's currency
- **OEM cross-reference numbers** — Original equipment numbers with vehicle-manufacturer attribution (the flagship field)
- **EAN barcode** — For matching against other catalogs
- **SKU & MPN** — Manufacturer part number, with and without separators
- **Vehicle compatibility** — Common vehicle models the part fits (up to 50 per product)
- **Technical specs** — Full attribute table (diameter, thickness, fitting position, surface, ...)
- **Availability** — InStock / OutOfStock status
- **Ratings & reviews** — Customer rating value and rating count
- **Product image** — Main image URL
- **Category & URL** — Category the product was found under and its canonical product URL

### How to scrape Autodoc data

1. Get a [Bright Data](https://brightdata.com) API key with a Web Unlocker zone (Autodoc runs a Cloudflare challenge on every request; regular proxies do not get through).
2. Pick one or more category URLs from the `/autoteile/` tree, for example `https://www.autodoc.de/autoteile/bremsscheibe-10132` (brake discs).
3. Set `maxResults` and run. The actor walks subcategories automatically when a single category page does not carry enough products.
4. Export the dataset as JSON, CSV, or Excel from the Apify Console or via API.

Keyword search URLs (`/search`) are not supported — drive the scraper with category URLs instead. Every category on the site has one, and the actor discovers subcategories on its own.

#### Input

| Field | Type | Description |
|-------|------|-------------|
| `categoryUrls` | Array | Category pages from the `/autoteile/` tree to scrape |
| `domain` | String | Storefront to scrape (default `www.autodoc.de`; also `.co.uk`, `.fr`, `.es`, `.it`, `.nl`, ...) |
| `fetchDetails` | Boolean | Fetch each product page for OEM/EAN/specs/compatibility (default `true`). Set `false` for fast listing-only data |
| `maxResults` | Integer | Maximum products to return (default: 100) |
| `brightDataApiKey` | String | Your Bright Data Web Unlocker API key (required) |
| `proxyConfiguration` | Object | Not used — all requests go through Bright Data |

#### Example input

```json
{
    "categoryUrls": [
        { "url": "https://www.autodoc.de/autoteile/bremsscheibe-10132" }
    ],
    "maxResults": 100,
    "fetchDetails": true
}
````

### Example output

```json
{
    "name": "BREMBO Prime 09.9772.11 Bremsscheibe",
    "brand": "BREMBO",
    "price": 47.49,
    "currency": "EUR",
    "sku": "09977211",
    "mpn": "09.9772.11",
    "ean": "8020584018286",
    "oemNumbers": [
        { "oemNumber": "5Q0615301F", "manufacturer": "VW / AUDI / SKODA / SEAT / CUPRA" },
        { "oemNumber": "1K0615301AA", "manufacturer": "VW / AUDI / SKODA / SEAT" },
        { "oemNumber": "JZW615301H", "manufacturer": "VW / SKODA / SEAT" }
    ],
    "compatibility": [
        "Golf 7 Bremsscheiben",
        "Golf 5 Bremsscheiben",
        "Audi A3 8P Bremsscheiben",
        "Tiguan 5N Bremsscheiben"
    ],
    "availability": "InStock",
    "inStock": true,
    "rating": 4,
    "reviewCount": 115,
    "imageUrl": "https://media.autodoc.de/360_photos/1657592/h-preview.jpg",
    "specs": {
        "Einbauposition": "Vorderachse",
        "Durchmesser": "312",
        "Bremsscheibenart": "innenbelüftet",
        "Oberfläche": "beschichtet"
    },
    "articleId": "1657592",
    "category": "Auto Bremsscheiben hinten und vorne",
    "url": "https://www.autodoc.de/brembo/1657592",
    "scrapedAt": "2026-07-11T10:32:18.512Z"
}
```

### How many results per run?

Each product's detail page is fetched individually (that is where the OEM and EAN data lives), at roughly 2–5 seconds per product with light concurrency. A 100-product run finishes in a few minutes; catalogue-scale runs take hours. The actor persists its crawl state, so long runs survive platform migrations and never push the same product twice.

With `fetchDetails: false` you get about 20 products per category page fetch — much faster and cheaper, but without OEM numbers, EAN, specs, or compatibility.

### Multi-country support

All Autodoc storefronts share one platform. To scrape another country, set `domain` and use category URLs from that domain:

```json
{
    "domain": "www.autodoc.co.uk",
    "categoryUrls": [{ "url": "https://www.autodoc.co.uk/car-parts/brake-disc-10132" }]
}
```

Prices come back in the local currency (EUR, GBP, ...).

### Limitations

- **Bright Data API key required.** Autodoc's Cloudflare protection blocks direct requests and datacenter proxies. A Web Unlocker zone handles it reliably; you pay Bright Data per request (typically well under a cent).
- **No keyword search.** The site's `/search` endpoint is not crawlable — use category URLs. The category tree covers the full catalog.
- **Category pages show top products only.** Each category page lists around 20 products; the actor compensates by walking subcategories. For full-catalogue coverage, seed multiple deep categories.
- **Compatibility list is capped at 50 vehicles** per product to keep items compact.

### Related Scrapers

- [Leroy Merlin Scraper](https://apify.com/jelle.desramaults/leroymerlin-scraper) — French DIY & home improvement products
- [ManoMano Scraper](https://apify.com/jelle.desramaults/manomano-scraper) — European DIY marketplace
- [Idealo Scraper](https://apify.com/jelle.desramaults/idealo-scraper) — German price comparison across categories
- [AutoTrader UK Scraper](https://apify.com/jelle.desramaults/autotrader-uk-scraper) — UK used-car listings

### FAQ

**Do I need an Autodoc account or cookies?**
No. Everything comes from public product pages.

**Can I scrape a single product?**
Seed the category the product sits in and set a low `maxResults`, or run with `fetchDetails: true` and filter the output by `articleId`.

**Is scraping Autodoc legal?**
This actor extracts publicly available product-page data (prices, part numbers, availability). You are responsible for how you use the data; check the terms that apply to your use case.

**Why do a few products come back without OEM numbers?**
Universal parts and accessories have no OEM cross-references on their pages. The field is populated whenever the site shows it.

# Actor input Schema

## `categoryUrls` (type: `array`):

Autodoc category pages to scrape (the /autoteile/ tree, e.g. https://www.autodoc.de/autoteile/bremsscheibe-10132). The scraper harvests product links from each category and walks its subcategories for breadth. Keyword search URLs (/search) are not supported.

## `domain` (type: `string`):

Which Autodoc storefront to scrape. All ~27 country domains share the same platform: www.autodoc.de, www.autodoc.co.uk, www.autodoc.fr, www.autodoc.es, www.autodoc.it, www.autodoc.nl, and more. Category URLs must belong to this domain.

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

When enabled (recommended), every product page is fetched to extract OEM cross-reference numbers, EAN codes, full specs, and vehicle compatibility. When disabled, only the cheap listing-tile data (name, brand, price, rating) is returned — faster, but without the OEM/EAN data.

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

Maximum number of products to return. Detail pages take a few seconds each, so size long runs accordingly.

## `brightDataApiKey` (type: `string`):

Your Bright Data API key for the Web Unlocker zone. Required to bypass Autodoc's Cloudflare protection. Get one at https://brightdata.com

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

Not used — all requests go through Bright Data Web Unlocker. Kept for compatibility.

## Actor input object example

```json
{
  "categoryUrls": [
    {
      "url": "https://www.autodoc.de/autoteile/bremsscheibe-10132"
    }
  ],
  "domain": "www.autodoc.de",
  "fetchDetails": true,
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "categoryUrls": [
        {
            "url": "https://www.autodoc.de/autoteile/bremsscheibe-10132"
        }
    ],
    "domain": "www.autodoc.de",
    "fetchDetails": true,
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/autodoc-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 = {
    "categoryUrls": [{ "url": "https://www.autodoc.de/autoteile/bremsscheibe-10132" }],
    "domain": "www.autodoc.de",
    "fetchDetails": True,
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/autodoc-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 '{
  "categoryUrls": [
    {
      "url": "https://www.autodoc.de/autoteile/bremsscheibe-10132"
    }
  ],
  "domain": "www.autodoc.de",
  "fetchDetails": true,
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/autodoc-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Autodoc Scraper — Car Parts with OEM Numbers & EAN",
        "description": "Scrape car parts from autodoc.de: names, brands, prices, OEM cross-reference numbers, EAN codes, manufacturer part numbers, vehicle compatibility, specs, ratings, and stock. Crawls the category tree and product pages. Works across Autodoc's EU storefronts (.de, .co.uk, .fr, .es, .it and more).",
        "version": "0.1",
        "x-build-id": "ny7fcWGr07YhSQIL6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~autodoc-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-autodoc-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~autodoc-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-autodoc-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~autodoc-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-autodoc-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": {
                    "categoryUrls": {
                        "title": "Category URLs",
                        "type": "array",
                        "description": "Autodoc category pages to scrape (the /autoteile/ tree, e.g. https://www.autodoc.de/autoteile/bremsscheibe-10132). The scraper harvests product links from each category and walks its subcategories for breadth. Keyword search URLs (/search) are not supported.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "domain": {
                        "title": "Autodoc domain",
                        "type": "string",
                        "description": "Which Autodoc storefront to scrape. All ~27 country domains share the same platform: www.autodoc.de, www.autodoc.co.uk, www.autodoc.fr, www.autodoc.es, www.autodoc.it, www.autodoc.nl, and more. Category URLs must belong to this domain.",
                        "default": "www.autodoc.de"
                    },
                    "fetchDetails": {
                        "title": "Fetch product detail pages",
                        "type": "boolean",
                        "description": "When enabled (recommended), every product page is fetched to extract OEM cross-reference numbers, EAN codes, full specs, and vehicle compatibility. When disabled, only the cheap listing-tile data (name, brand, price, rating) is returned — faster, but without the OEM/EAN data.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of products to return. Detail pages take a few seconds each, so size long runs accordingly.",
                        "default": 100
                    },
                    "brightDataApiKey": {
                        "title": "Bright Data API Key",
                        "type": "string",
                        "description": "Your Bright Data API key for the Web Unlocker zone. Required to bypass Autodoc's Cloudflare protection. Get one at https://brightdata.com"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Not used — all requests go through Bright Data Web Unlocker. Kept for compatibility."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
