# Vinted Scraper - Listings, Prices, Brands & Seller Data (`webdatalabs/vinted-scraper-pro`) Actor

Scrape Vinted listings and track what actually sells — across 17 markets, by keyword or URL.

- **URL**: https://apify.com/webdatalabs/vinted-scraper-pro.md
- **Developed by:** [WebDataLabs](https://apify.com/webdatalabs) (community)
- **Categories:** E-commerce, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 1,000 listing scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Vinted Scraper - Listings, Prices & Sold Tracking

Scrape Vinted listings and track what actually sells — across 17 markets, by keyword or URL.

### What is the Vinted Scraper?

**Vinted Scraper** pulls structured second-hand fashion data from [Vinted](https://www.vinted.com) across 17 markets in Europe and the US — search by keyword or paste any Vinted URL. It answers the two questions resellers live on: **what's available and underpriced right now**, and **what actually sold, for how much, and how fast**. Vinted publishes no official public API, so this is the reliable way to get clean, export-ready listing and sell-through data at volume. No code, no login, no proxies to manage.

### What data can you extract from Vinted?

The high-value fields (every run also returns the full flat record — see the dataset schema):

| Field | Example |
|-------|---------|
| `title` | `Nike Air Max 90 white` |
| `price` / `currency` / `priceWithFees` | `45` · `EUR` · `48.70` |
| `brand` / `size` / `condition` | `Nike` · `42` · `Very good` |
| `favouriteCount` | `23` (demand signal) |
| `photos` | array of image URLs |
| `sellerName` / `sellerIsBusiness` / `sellerProfileUrl` | `sneaker_shop_de` · `false` · profile link |
| `country` / `url` | `de` · direct listing link |
| **Track mode:** `changeType` / `daysListed` / `previousPrice` | `sold` · `7` · `55` |

### Example output

```json
{
  "id": "4567891234",
  "title": "Nike Air Max 90 white",
  "price": 45,
  "currency": "EUR",
  "priceWithFees": 48.7,
  "brand": "Nike",
  "size": "42",
  "condition": "Very good",
  "favouriteCount": 23,
  "photos": ["https://images1.vinted.net/t/abc/f800/photo.jpeg"],
  "sellerName": "sneaker_shop_de",
  "sellerIsBusiness": false,
  "sellerProfileUrl": "https://www.vinted.de/member/12345678",
  "country": "de",
  "url": "https://www.vinted.de/items/4567891234",
  "scrapedAt": "2026-07-01T12:00:00.000Z",
  "changeType": "sold",
  "firstSeenAt": "2026-06-20T09:14:00.000Z",
  "lastSeenAt": "2026-06-27T09:10:00.000Z",
  "daysListed": 7,
  "previousPrice": 55
}
````

### How do I scrape Vinted? (quick start)

1. **Enter a query** — a keyword like `nike air max`, or filter on Vinted's own site and paste the URL (brand/size/price filters carry over, so there are no IDs to look up).
2. **Pick countries** — a keyword is searched in every country you select.
3. **Choose a mode and run** — *Search* for a one-off pull, or *Track sales* to monitor over time, then export CSV / JSON / Excel or connect the dataset to your workflow.

Search a keyword across two markets:

```json
{ "query": ["nike air max"], "countries": ["de", "fr"], "maxItems": 200 }
```

Track sales on a filtered Vinted URL (run on a daily schedule):

```json
{ "query": ["https://www.vinted.de/catalog?search_text=jordan&brand_ids[]=53"], "mode": "track", "maxItems": 500 }
```

### What are the two modes: Search and Track sales?

- **Search** — returns current matching listings at volume. Best for market pulls and price research.
- **Track sales** — on each scheduled run, compares against the previous run for the same query and flags **new listings**, **price drops**, and **sold items** (an item that disappears from Vinted search). Each query keeps its own history, so you build a running record of what sold, for how much, and after how many days.

### How much does it cost to scrape Vinted?

**Pay per listing returned** — you only pay for the results you get, with no monthly subscription and no per-run start fee. The current rate is shown in the pricing box on this page. Residential proxies are included, so you never buy or configure proxies. Tip: start with a small `Max listings` value to keep test runs cheap.

### Who uses the Vinted Scraper?

- **Sneaker & streetwear flippers** — search a brand, sort by price low-to-high, and act on listings with a high `favouriteCount` (hot items) priced below the market.
- **Cross-border arbitrage resellers** — run the same keyword in `pl`, `de`, and `fr`, compare `price`, and source where a category is cheap to resell where it's rich.
- **Vinted power sellers & shops** — Track mode tells you which brands/sizes sell fastest (`daysListed`) and at what final price, so you price and restock with data.
- **Brand & market researchers** — measure second-hand pricing, brand demand, and sell-through across EU markets over time.
- **Repricing & inventory tools** — pipe clean JSON/CSV into n8n, Zapier, Make, or Google Sheets as a pricing feed.

### How does sold-item detection work?

Vinted publishes no sold list and no sold-price API. Track mode infers a sale when a listing **disappears from search** between scheduled runs — the standard method across the market. It's a strong signal (sold items drop out of search), but a disappearance can occasionally mean the seller paused or removed the listing rather than sold it. `daysListed` and the last-seen price are your best available "sold price" proxy, not a Vinted-confirmed figure. For the cleanest results, track a **stable, filtered query** on a daily schedule.

### Which countries are supported?

Germany, France, United Kingdom, Italy, Spain, Netherlands, Poland, Belgium, Austria, Portugal, Czechia, Slovakia, Hungary, Romania, Lithuania, Luxembourg, and USA / International — 17 Vinted marketplaces, each in its local currency.

### FAQ

#### Is it legal to scrape Vinted?

This tool collects only publicly visible listing data. You are responsible for complying with Vinted's Terms and the law in your region. Don't use it to spam or to resell personal data.

#### Do I need proxies or a Vinted account?

No. Residential proxies are built in, and no login is required — it reads public listings only.

#### How do I track sold items and price history?

Choose *Track sales* mode and **schedule** the actor (Apify → Schedules). The first run is a baseline; every later run reports what's new, what dropped in price, and what sold since.

#### Can I filter by brand, size, condition, or price?

Yes. For a keyword search, use the Advanced inputs (price, condition, sort). For anything more specific, filter on Vinted's own site and paste the resulting URL — its brand/size/category filters are applied automatically.

#### Can I scrape a specific seller or a single item URL?

Not yet — seller-profile and single-item scraping are on the roadmap (those endpoints have stricter protection). Use a keyword or a search URL for now.

#### Can I export to CSV, Excel, or Google Sheets?

Yes. Every run's dataset exports to CSV, JSON, Excel, or XML, or connects via API and webhooks to n8n, Zapier, and Make.

#### Why did a run return fewer items than my limit?

That query simply has fewer live listings, or Vinted's per-search result cap was reached.

#### What are the data limitations?

`viewCount`, seller ratings, and full item descriptions live on Vinted's item-detail endpoint, which is not covered in this version. Sold data is inferred (see above), not Vinted-confirmed.

### Related actors

- [eBay Scraper Pro](https://apify.com/webdatalabs/ebay-scraper-pro) — cross-check resale comps on eBay.
- [Etsy Scraper Pro](https://apify.com/webdatalabs/etsy-scraper-pro) — handmade & vintage pricing.
- [Reddit Scraper Pro](https://apify.com/webdatalabs/reddit-scraper-pro) — monitor r/flipping and deal chatter.

### Support

Found a bug, or need a field or country added? Open a ticket on the actor's **Issues** tab, or reach the team via the [WebDataLabs profile](https://apify.com/webdatalabs). We keep the scraper updated when Vinted changes its site.

# Actor input Schema

## `query` (type: `array`):

One or more of: a keyword (e.g. 'nike air max'), or a full Vinted search URL (filter on Vinted's site, then copy the URL — brand/size/price filters carry over, no IDs to look up). Add several to scrape them all.

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

Which Vinted country marketplaces to search. A keyword is searched in every selected country (more countries = more results, and lets you compare prices across markets). Ignored for pasted URLs (the URL already points at a country).

## `mode` (type: `string`):

Search = get current matching listings. Track sales = compare against the previous scheduled run for the same query and flag NEW listings, PRICE DROPS, and SOLD items (items that disappeared from search — how long they were listed and their last price). Track sales only makes sense on a schedule (e.g. daily); run it once to set a baseline, then let it run.

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

Maximum listings to return per query (per country). Start small (100) to keep test runs cheap; raise for production.

## `priceFrom` (type: `integer`):

Only listings at or above this price (local currency). Applies to keyword searches; ignored for pasted URLs.

## `priceTo` (type: `integer`):

Only listings at or below this price (local currency). Applies to keyword searches.

## `condition` (type: `array`):

Filter keyword searches by item condition. Leave empty for all conditions.

## `sort` (type: `string`):

Sort order for keyword searches.

## `useApifyProxy` (type: `boolean`):

Required. Vinted blocks datacenter IPs immediately; this actor uses residential proxies to work reliably. Only disable for debugging.

## Actor input object example

```json
{
  "query": [
    "nike air max"
  ],
  "countries": [
    "de"
  ],
  "mode": "search",
  "maxItems": 100,
  "condition": [],
  "sort": "relevance",
  "useApifyProxy": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `sales` (type: `string`):

No description

## `full_data` (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 = {
    "query": [
        "nike air max"
    ],
    "countries": [
        "de"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdatalabs/vinted-scraper-pro").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 = {
    "query": ["nike air max"],
    "countries": ["de"],
}

# Run the Actor and wait for it to finish
run = client.actor("webdatalabs/vinted-scraper-pro").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 '{
  "query": [
    "nike air max"
  ],
  "countries": [
    "de"
  ]
}' |
apify call webdatalabs/vinted-scraper-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vinted Scraper - Listings, Prices, Brands & Seller Data",
        "description": "Scrape Vinted listings and track what actually sells — across 17 markets, by keyword or URL.",
        "version": "1.0",
        "x-build-id": "VTAh8RVzqaQmEfTJR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdatalabs~vinted-scraper-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdatalabs-vinted-scraper-pro",
                "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/webdatalabs~vinted-scraper-pro/runs": {
            "post": {
                "operationId": "runs-sync-webdatalabs-vinted-scraper-pro",
                "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/webdatalabs~vinted-scraper-pro/run-sync": {
            "post": {
                "operationId": "run-sync-webdatalabs-vinted-scraper-pro",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search or paste Vinted URL",
                        "type": "array",
                        "description": "One or more of: a keyword (e.g. 'nike air max'), or a full Vinted search URL (filter on Vinted's site, then copy the URL — brand/size/price filters carry over, no IDs to look up). Add several to scrape them all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Which Vinted country marketplaces to search. A keyword is searched in every selected country (more countries = more results, and lets you compare prices across markets). Ignored for pasted URLs (the URL already points at a country).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "de",
                                "fr",
                                "nl",
                                "it",
                                "es",
                                "co.uk",
                                "pl",
                                "be",
                                "at",
                                "pt",
                                "cz",
                                "sk",
                                "hu",
                                "ro",
                                "lt",
                                "lu",
                                "com"
                            ],
                            "enumTitles": [
                                "Germany",
                                "France",
                                "Netherlands",
                                "Italy",
                                "Spain",
                                "United Kingdom",
                                "Poland",
                                "Belgium",
                                "Austria",
                                "Portugal",
                                "Czechia",
                                "Slovakia",
                                "Hungary",
                                "Romania",
                                "Lithuania",
                                "Luxembourg",
                                "USA / International"
                            ]
                        },
                        "default": [
                            "de"
                        ]
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "track"
                        ],
                        "type": "string",
                        "description": "Search = get current matching listings. Track sales = compare against the previous scheduled run for the same query and flag NEW listings, PRICE DROPS, and SOLD items (items that disappeared from search — how long they were listed and their last price). Track sales only makes sense on a schedule (e.g. daily); run it once to set a baseline, then let it run.",
                        "default": "search"
                    },
                    "maxItems": {
                        "title": "Max listings per query",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum listings to return per query (per country). Start small (100) to keep test runs cheap; raise for production.",
                        "default": 100
                    },
                    "priceFrom": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only listings at or above this price (local currency). Applies to keyword searches; ignored for pasted URLs."
                    },
                    "priceTo": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only listings at or below this price (local currency). Applies to keyword searches."
                    },
                    "condition": {
                        "title": "Condition",
                        "type": "array",
                        "description": "Filter keyword searches by item condition. Leave empty for all conditions.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "new_with_tags",
                                "new_without_tags",
                                "very_good",
                                "good",
                                "satisfactory"
                            ],
                            "enumTitles": [
                                "New with tags",
                                "New without tags",
                                "Very good",
                                "Good",
                                "Satisfactory"
                            ]
                        },
                        "default": []
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "newest_first",
                            "price_low_to_high",
                            "price_high_to_low"
                        ],
                        "type": "string",
                        "description": "Sort order for keyword searches.",
                        "default": "relevance"
                    },
                    "useApifyProxy": {
                        "title": "Use Apify residential proxy",
                        "type": "boolean",
                        "description": "Required. Vinted blocks datacenter IPs immediately; this actor uses residential proxies to work reliably. Only disable for debugging.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
