# Vinted Scraper (`apium/vinted-scraper`) Actor

Vinted scraper for bulk listings, seller profiles and item details. Paste any vinted.\* catalog URL or just type a search + market. Uses the Vinted API for prices, brands, sizes, condition, seller data and photos. Ideal for vinted data export, price monitoring and reseller research.

- **URL**: https://apify.com/apium/vinted-scraper.md
- **Developed by:** [Tommi Sullivan](https://apify.com/apium) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result items

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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/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

## Vinted Scraper — Bulk Listings, Sellers & Item Details (Pay Per Result)

**The reliable, deepest-field Vinted scraper.** Turn any Vinted search, catalog page, item, or seller into clean structured data. Paste a filtered Vinted URL **or** just type a search term and pick a market — get back prices, brands, sizes, conditions, seller info, photos, favourites, and the real buyer-protection price. Browserless, actively maintained, and **pay-per-result**, so you only pay for the listings you actually get.

Works across **every Vinted market** — vinted.com, .co.uk, .de, .fr, .it, .es, .nl, .pl, and 15+ more.

> Keywords: vinted scraper, vinted api, vinted data export, vinted price monitoring, scrape vinted, vinted reseller tool.

---

### Why this actor

The Vinted scraping niche is fragmented: the highest-user actors are stale subscription tools that break and go unmaintained, and the one genuinely live competitor is priced as an arbitrage/monitoring suite, not a clean bulk-export tool. This actor is built to win on the things that actually matter here:

- **Reliable through Datadome cycles.** Vinted is protected by Datadome, which breaks scrapers on a 3–6 month cycle. This actor uses Chrome TLS/JA3 impersonation + residential proxies + automatic IP rotation and cooldown on blocks, and is actively maintained. Reliability is the moat.
- **Deepest, best-named fields.** Including the ones competitors bury — `total_item_price` (the real landed price with buyer protection), `service_fee`, seller feedback, `favourites`, and `view_count`.
- **Fair pay-per-result pricing.** No monthly subscription. You pay only for results returned. See [PRICING.md](PRICING.md).
- **No URL-building required.** Type a search term + pick a market, or paste a filtered URL. Most competitors force you to build URLs.

---

### What it does

- Scrapes Vinted **search results and catalog pages** into structured JSON / CSV / Excel.
- Accepts a **filtered Vinted URL** (all your filters respected) **or** a **plain search term + market**.
- Scrapes **specific items** by ID (full detail: description, all photos, colour, material).
- Scrapes **sellers** by ID — their profile (feedback, followers, items sold, business flag) plus their active listings.
- Exposes the **real landed price** (`total_item_price`), not just the sticker.
- Honors your **result limits** — set `maxItems` / `maxResultsPerUrl` and never overspend.
- **Deduplicates** by item ID across all inputs.

---

### Input

| Field | Type | Description |
|---|---|---|
| `searchUrls` | array | Filtered Vinted catalog/search URLs from any market. Power-user path. |
| `searchQueries` | array | Plain-text searches (used with `market`) — no URL needed. |
| `market` | string | Vinted TLD for queries/items/sellers, e.g. `com`, `co.uk`, `de`, `fr`. |
| `itemIds` | array | Item IDs or item URLs for full detail scrape. |
| `sellerIds` | array | Member IDs or URLs to pull a seller's profile + listings. |
| `maxItems` | integer | Global cap on total results pushed (spend control). Default `500`. |
| `maxResultsPerUrl` | integer | Cap per URL/query (Vinted caps a single query at ~960). |
| `sortBy` | string | `relevance` / `newest_first` / `price_low_to_high` / `price_high_to_low`. |
| `priceFrom` / `priceTo` | integer | Price band for `searchQueries`. |
| `proxyConfiguration` | object | Proxy config. **Residential is default and required.** User-overridable. |

#### Input example

```json
{
  "searchQueries": ["carhartt jacket"],
  "market": "co.uk",
  "sortBy": "newest_first",
  "priceFrom": 20,
  "priceTo": 80,
  "maxItems": 500,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

***

### Output

Every listing is flattened to a flat, analysis-ready record.

| Field | Type | Description |
|---|---|---|
| `id` | number | Vinted item ID (used for dedup). |
| `title` | string | Listing title. |
| `price` | number | Sticker price. |
| `currency` | string | ISO currency code (e.g. `GBP`, `EUR`). |
| `total_item_price` | number | **Real landed price** incl. buyer-protection fee. |
| `service_fee` | number | Buyer-protection / service fee. |
| `brand` | string | Brand name. |
| `size` | string | Size label. |
| `condition` | string | Item condition/status. |
| `seller` | object | `{ id, login, feedback, business, profile_url }`. |
| `favourites` | number | Favourite count. |
| `view_count` | number | View count. |
| `photos` | array | All photo URLs. |
| `url` | string | Canonical listing URL. |
| `market` | string | Market TLD the item came from. |
| `scraped_at` | string | ISO-8601 UTC scrape timestamp. |

Item-detail records add `description`, `color`, `material`, `uploaded_at`. Seller records add `feedback`, `followers_count`, `item_count`, `is_business`, `verified`, and more.

#### Output example

```json
{
  "id": 6264122841,
  "title": "Carhartt Detroit Jacket",
  "price": 45.0,
  "currency": "GBP",
  "total_item_price": 48.5,
  "service_fee": 3.5,
  "brand": "Carhartt",
  "size": "M",
  "condition": "Very good",
  "seller": { "id": 263345370, "login": "detroit_finds", "feedback": 214, "business": false, "profile_url": "https://www.vinted.co.uk/member/263345370" },
  "favourites": 22,
  "view_count": 310,
  "photos": ["https://images1.vinted.net/...jpeg", "https://images1.vinted.net/...jpeg"],
  "url": "https://www.vinted.co.uk/items/6264122841-carhartt-jacket",
  "market": "co.uk",
  "scraped_at": "2026-07-04T09:00:00Z"
}
```

***

### Use cases

- **Reseller arbitrage** — spot under-priced inventory and cross-market price gaps (a jacket cheaper on `.de` than `.co.uk`). `total_item_price` shows the real landed cost.
- **Price monitoring** — schedule recurring runs on a saved search and track price/availability over time; wire to alerts.
- **Brand research** — pull every listing for a brand across markets to analyse pricing, sell-through, sizes, and condition mix.
- **Sourcing & dataset building** — build second-hand fashion datasets for analytics or AI, or monitor specific sellers for new drops.

***

### Integrations

- **Export** to JSON, CSV, Excel, or Google Sheets.
- **Apify API** — pull results programmatically, schedule runs, stream to webhooks.
- **Make / n8n / Zapier** — no-code automation for price monitoring and inventory alerts.
- **LangChain / MCP agents** — this actor is exposed as an **MCP tool**. Connect it to Claude, ChatGPT, or any MCP client and ask *"find Carhartt jackets under £50 in very-good condition on Vinted UK"* to get structured results back into your agent.

***

### FAQ

**Do I need a Vinted account or the Vinted Pro API?**
No. Vinted's official Pro API is allowlist-only. This actor uses Vinted's public catalog — no login required.

**Which markets are supported?**
All major Vinted domains — set `market` or paste a URL from any `vinted.*` site.

**Why are residential proxies required?**
Vinted is protected by **Datadome**, which fingerprints your TLS handshake and checks IP reputation. Datacenter IPs are blocked almost immediately. Residential proxies keep success rates high — this is an unavoidable cost floor for *every* Vinted scraper, not just this one. Honest cost note: residential proxy traffic is the bulk of the run cost (compute is near-zero because there's no browser). See [PRICING.md](PRICING.md) for the full breakdown.

**Can I get more than ~960 results per search?**
No — Vinted itself caps a single query at ~960 items. Split by extra filters (brand, size, price band) to go deeper; the actor deduplicates across inputs automatically.

**How current is the data?**
Live at run time.

***

### Legality

This actor collects only **publicly available** listing data from Vinted's public catalog. It does not access private data, log into accounts on your behalf, or bypass authentication. You are responsible for using scraped data in line with Vinted's terms and applicable law (e.g. GDPR for any personal data). Not affiliated with or endorsed by Vinted Limited.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste one or more filtered Vinted catalog or search URLs from any market (e.g. https://www.vinted.co.uk/catalog?search\_text=carhartt+jacket\&brand\_ids\[]=362). All filters in the URL are respected. This is the power-user path.

## `searchQueries` (type: `array`):

Plain-text searches, used together with the 'market' field below. Use this when you don't want to build a URL. Example: 'carhartt jacket'.

## `market` (type: `string`):

The Vinted market used for 'searchQueries', 'itemIds' and 'sellerIds'. Choose the country domain, e.g. com, co.uk, de, fr. URLs in 'searchUrls' keep their own market.

## `itemIds` (type: `array`):

Specific Vinted item IDs to fetch full item details for (uses the 'market' field). Accepts numeric IDs or full item URLs.

## `sellerIds` (type: `array`):

Vinted member/seller IDs whose active listings you want to scrape (uses the 'market' field). Accepts numeric IDs or full member URLs.

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

Hard cap on the total number of results pushed across the whole run. Protects you from overspending. The Actor stops cleanly once reached.

## `maxResultsPerUrl` (type: `integer`):

Cap on results scraped per individual search URL or query (Vinted itself caps a single query at ~960 items). Leave empty to scrape everything up to that cap.

## `sortBy` (type: `string`):

Sort order applied to searches created from 'searchQueries'. Ignored for URLs that already specify their own order.

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

Minimum price filter for searches created from 'searchQueries' (in the market's currency).

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

Maximum price filter for searches created from 'searchQueries' (in the market's currency).

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

Proxy settings. Residential proxies are REQUIRED for reliable Vinted scraping (Vinted is protected by Datadome). Residential is the default; power users may override with their own proxy.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.vinted.co.uk/catalog?search_text=carhartt%20jacket&order=newest_first"
  ],
  "market": "com",
  "maxItems": 500,
  "sortBy": "newest_first",
  "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 = {
    "searchUrls": [
        "https://www.vinted.co.uk/catalog?search_text=carhartt%20jacket&order=newest_first"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("apium/vinted-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 = {
    "searchUrls": ["https://www.vinted.co.uk/catalog?search_text=carhartt%20jacket&order=newest_first"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("apium/vinted-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 '{
  "searchUrls": [
    "https://www.vinted.co.uk/catalog?search_text=carhartt%20jacket&order=newest_first"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call apium/vinted-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vinted Scraper",
        "description": "Vinted scraper for bulk listings, seller profiles and item details. Paste any vinted.* catalog URL or just type a search + market. Uses the Vinted API for prices, brands, sizes, condition, seller data and photos. Ideal for vinted data export, price monitoring and reseller research.",
        "version": "0.1",
        "x-build-id": "V4b3PJV18VMBbeOex"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apium~vinted-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apium-vinted-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/apium~vinted-scraper/runs": {
            "post": {
                "operationId": "runs-sync-apium-vinted-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/apium~vinted-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-apium-vinted-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "proxyConfiguration"
                ],
                "properties": {
                    "searchUrls": {
                        "title": "Search / catalog URLs",
                        "type": "array",
                        "description": "Paste one or more filtered Vinted catalog or search URLs from any market (e.g. https://www.vinted.co.uk/catalog?search_text=carhartt+jacket&brand_ids[]=362). All filters in the URL are respected. This is the power-user path.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Plain-text searches, used together with the 'market' field below. Use this when you don't want to build a URL. Example: 'carhartt jacket'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "market": {
                        "title": "Market (Vinted TLD)",
                        "enum": [
                            "com",
                            "co.uk",
                            "de",
                            "fr",
                            "it",
                            "es",
                            "nl",
                            "be",
                            "at",
                            "pl",
                            "cz",
                            "sk",
                            "lt",
                            "lu",
                            "pt",
                            "se",
                            "dk",
                            "fi",
                            "ro",
                            "hu",
                            "gr",
                            "hr",
                            "ie"
                        ],
                        "type": "string",
                        "description": "The Vinted market used for 'searchQueries', 'itemIds' and 'sellerIds'. Choose the country domain, e.g. com, co.uk, de, fr. URLs in 'searchUrls' keep their own market.",
                        "default": "com"
                    },
                    "itemIds": {
                        "title": "Item IDs (detail scrape)",
                        "type": "array",
                        "description": "Specific Vinted item IDs to fetch full item details for (uses the 'market' field). Accepts numeric IDs or full item URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sellerIds": {
                        "title": "Seller IDs",
                        "type": "array",
                        "description": "Vinted member/seller IDs whose active listings you want to scrape (uses the 'market' field). Accepts numeric IDs or full member URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items (total spend cap)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the total number of results pushed across the whole run. Protects you from overspending. The Actor stops cleanly once reached.",
                        "default": 500
                    },
                    "maxResultsPerUrl": {
                        "title": "Max results per URL / query",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap on results scraped per individual search URL or query (Vinted itself caps a single query at ~960 items). Leave empty to scrape everything up to that cap."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "newest_first",
                            "price_low_to_high",
                            "price_high_to_low"
                        ],
                        "type": "string",
                        "description": "Sort order applied to searches created from 'searchQueries'. Ignored for URLs that already specify their own order.",
                        "default": "newest_first"
                    },
                    "priceFrom": {
                        "title": "Price from",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price filter for searches created from 'searchQueries' (in the market's currency)."
                    },
                    "priceTo": {
                        "title": "Price to",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price filter for searches created from 'searchQueries' (in the market's currency)."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are REQUIRED for reliable Vinted scraping (Vinted is protected by Datadome). Residential is the default; power users may override with their own proxy.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
