# Vestiaire Collective Listings Scraper (`piotrv1001/vestiaire-collective-listings-scraper`) Actor

The Vestiaire Collective Scraper extracts product listings and enriched profiles from Vestiaire Collective, capturing names, brands, models, prices, conditions, materials, measurements, seller profiles, and images — ideal for luxury resale price tracking and market research.

- **URL**: https://apify.com/piotrv1001/vestiaire-collective-listings-scraper.md
- **Developed by:** [FalconScrape](https://apify.com/piotrv1001) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 product listings

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

## 🛍️ Vestiaire Collective Listings Scraper

Easily extract product listings from **[Vestiaire Collective](https://www.vestiairecollective.com/)**, the global resale marketplace for pre-owned luxury fashion. The **Vestiaire Collective Listings Scraper** gathers structured product data — name, brand, price, condition, seller, and images — for resale market analysis, price tracking, and catalog building, with optional deep product-detail enrichment.

Run it on the [Apify platform](https://apify.com) for API access, scheduling, integrations (Make, Zapier, Google Sheets, webhooks), automatic proxy rotation, and run monitoring.

### ✨ Features

- 🏷️ **Comprehensive Listing Data**: Retrieve product name, description, brand, model, price, colors, likes, seller, images, and availability in a single pass.
- 🔍 **Flexible Search**: Scrape by free-text queries (brand/model/keyword) or browse whole categories with catalog filters.
- 🔬 **Optional Deep Enrichment**: Turn on **Fetch product details** to add measurements, material, condition, full pricing breakdown (seller earnings, buyer fees, duty/tax), the complete image set, and the full seller profile with ratings.
- 🌍 **Localization**: Choose country, currency, language, and size system for accurate, localized pricing.
- ⚡ **Fast & Reliable**: Clears Cloudflare automatically and enriches details over plain HTTP for efficient, large-scale extraction.
- 💸 **Pay Only For What You Need**: Two-tier pay-per-event pricing — cheap shallow listings, premium detail only when you want it.

### 🛠️ How It Works

1. **Enter search queries or filters** – Provide brand/keyword search terms, or set catalog filters to target a category.
2. **(Optional) Enable Fetch product details** – Add rich per-item data when you need the deepest information.
3. **Run the scraper** – Start the run and receive clean, structured JSON in the dataset, downloadable as JSON, CSV, Excel, or HTML.

### ⚙️ Input

Configure the run from the **Input** tab or via JSON. Available fields:

| Field                 | Key                   | Type    | Default           | Description                                                                                                 |
| --------------------- | --------------------- | ------- | ----------------- | ----------------------------------------------------------------------------------------------------------- |
| Search queries        | `searchQueries`       | array   | `[]`              | Free-text search terms. Each query is scraped separately (capped at ~1,020 listings per query by the site). |
| Catalog filters       | `filters`             | object  | `{}`              | Vestiaire facet IDs applied to every search, e.g. `{"categoryLvl0.id":["5"],"universe.id":["1"]}`.          |
| Sort by               | `sortBy`              | string  | `relevance`       | Result ordering: `relevance`, `priceAsc`, `priceDesc`, `mostRecent`, `popularity`.                          |
| Max items             | `maxItems`            | integer | `50`              | Maximum number of unique listings to scrape across all queries.                                             |
| Fetch product details | `fetchProductDetails` | boolean | `false`           | Enrich every listing with the product-detail API.                                                           |
| Country               | `country`             | string  | `US`              | ISO country code for localized pricing and availability.                                                    |
| Currency              | `currency`            | string  | `USD`             | Currency code for prices.                                                                                   |
| Language              | `language`            | string  | `en`              | Language code for localized text.                                                                           |
| Size type             | `sizeType`            | string  | `US`              | Size system for size facets (e.g. US, FR, IT).                                                              |
| Site ID               | `siteId`              | integer | _(auto)_          | Advanced override of the Vestiaire site id for the detail API (derived from country if empty).              |
| Proxy configuration   | `proxyConfiguration`  | object  | Apify Residential | Proxy settings. Residential proxies are recommended to reliably clear Cloudflare.                           |

#### Input example

```json
{
    "searchQueries": ["Louis Vuitton handbag"],
    "filters": { "categoryLvl0.id": ["5"], "categoryLvl1.id": ["59"], "universe.id": ["1"] },
    "sortBy": "relevance",
    "maxItems": 50,
    "fetchProductDetails": true,
    "country": "US",
    "currency": "USD",
    "language": "en",
    "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

> **Tip — finding filter IDs:** open any category on the site, apply the filters you want, and read the facet IDs from the page's catalog data. Common top-level IDs include Bags (`5`) and the Women universe (`1`).

### 📊 Sample Output Data

The scraper provides structured JSON output with key product details. Example:

```json
[
    {
        "id": 66581578,
        "url": "https://www.vestiairecollective.com/women-bags/handbags/louis-vuitton/blue-denim-jeans-baggy-louis-vuitton-handbag-66581578.shtml",
        "name": "Baggy handbag",
        "description": "Louis Vuitton 'Baggy PM' Shoulder Bag in denim. ...",
        "brand": "Louis Vuitton",
        "brandId": 17,
        "model": "Baggy",
        "priceAmount": 5509,
        "priceCurrency": "USD",
        "likes": 17,
        "sold": false,
        "inStock": true,
        "country": "US",
        "colors": ["Blue"],
        "sellerId": 8373199,
        "sellerName": "linda",
        "sellerIsOfficialStore": false,
        "pictures": ["https://images.vestiairecollective.com/produit/66581578-1_1.jpg"],
        "universeId": 1,
        "dutyFree": true,
        "createdAt": "2026-06-03T10:01:49.000Z",
        "searchQuery": "Louis Vuitton handbag"
    }
]
```

When **Fetch product details** is enabled, each item additionally includes `condition`, `material`, `measurements`, `category`, `subcategory`, `pricingBreakdown`, `buyerFees`, `dutyAndTax`, `sellerDetail`, and the full `detailPictures` set.

#### Output fields

| Field                                                                            | Description                     |
| -------------------------------------------------------------------------------- | ------------------------------- |
| `id`                                                                             | Vestiaire product ID            |
| `url`                                                                            | Canonical product page URL      |
| `name` / `description`                                                           | Listing title and description   |
| `brand` / `brandId` / `model`                                                    | Brand and model                 |
| `priceAmount` / `priceCurrency`                                                  | Price and currency              |
| `likes`                                                                          | Number of likes                 |
| `sold` / `inStock`                                                               | Availability flags              |
| `colors`                                                                         | Color names                     |
| `sellerId` / `sellerName` / `sellerIsOfficialStore`                              | Seller info                     |
| `pictures`                                                                       | Image URLs                      |
| `createdAt`                                                                      | Listing creation time (ISO)     |
| `condition`, `material`, `measurements`, `pricingBreakdown`, `sellerDetail`, ... | Detail-only fields (enrichment) |

### 💡 Tips & Advanced Options

- **Per-query cap:** Vestiaire caps each query at about **1,020 listings** (17 pages of 60). To collect a whole large category, split it into narrower searches — by brand, price range, condition, color, or sub-category.
- **Localization:** prices follow the `country`/`currency` you set, so set them explicitly for consistent values.
- **Deduplication:** listings are deduplicated by ID across all queries automatically.
- **Cost control:** start with **Fetch product details** off — listing data alone is already rich — and use residential proxies so sessions clear reliably (fewer retries = lower cost).

### ❓ FAQ & Disclaimer

**Is scraping Vestiaire Collective legal?** This Actor collects only publicly available catalog data and does not require login. You are responsible for using the data in compliance with Vestiaire Collective's Terms of Service, applicable laws, and data-protection regulations.

**Why do some items have no details?** Sold or inactive items return no detail payload; those listings are still included with their listing-level fields (and aren't charged for detail).

**Support:** Found a bug or need a custom field? Open an issue in the Actor's **Issues** tab.

### 💰 Pricing

This Actor uses a transparent **pay-per-event** model — you pay only for the data you actually receive. Leave enrichment off for cheap bulk discovery, or turn it on only when you need the deepest data. The Actor automatically stops once your run's charging limit is reached, so you never exceed your budget.

| Event                                   | Price (USD) | When it's charged                          | What you get                                                                                          |
| --------------------------------------- | ----------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------- |
| **Product listing** (`product-listing`) | **$0.005**  | Once per unique listing scraped            | Name, brand, model, price, colors, likes, seller, image, availability, description                    |
| **Item detail** (`item-detail`)         | **$0.015**  | Additionally, per detailed profile fetched | Measurements, material, condition, full pricing breakdown, 9 images, full seller profile with ratings |

- **Shallow mode** (Fetch product details OFF): **$0.005 / item**.
- **Full-detail mode** (Fetch product details ON): **$0.020 / item** (`product-listing` + `item-detail`).

#### Example run costs

| Scenario                    | Cost   |
| --------------------------- | ------ |
| 50 listings, shallow        | $0.25  |
| 50 listings, full detail    | $1.00  |
| 1,000 listings, shallow     | $5.00  |
| 1,000 listings, full detail | $20.00 |

Optimize your luxury resale strategy with the **Vestiaire Collective Listings Scraper** today! 🚀

# Actor input Schema

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

Free-text search terms (e.g. brand or model names). Each query is scraped as its own search, capped at ~1,020 listings per query by the site. Leave empty to browse by filters only.

## `filters` (type: `object`):

Vestiaire Collective catalog filters keyed by facet id, applied to every search. Example: {"categoryLvl0.id": \["5"], "categoryLvl1.id": \["59"], "universe.id": \["1"]} for Women > Bags > Handbags. IDs come from the site's category facets.

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

Result ordering used by the search API.

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

Maximum number of unique listings to scrape across all search queries.

## `fetchProductDetails` (type: `boolean`):

Enrich every listing with the product-detail API (measurements, condition, material, full image set, pricing breakdown, full seller profile). Adds cheap plain-HTTP requests per listing.

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

ISO country code for localized pricing and availability.

## `currency` (type: `string`):

Currency code for prices.

## `language` (type: `string`):

Language code for localized text.

## `sizeType` (type: `string`):

Size system for size facets (e.g. US, FR, IT).

## `siteId` (type: `integer`):

Override the Vestiaire site id used by the product-detail API. Leave empty to derive it from the country (US = 5).

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

Proxy settings. Residential proxies are recommended to reliably clear Cloudflare on the listing API.

## Actor input object example

```json
{
  "searchQueries": [
    "Louis Vuitton handbag"
  ],
  "filters": {},
  "sortBy": "relevance",
  "maxItems": 50,
  "fetchProductDetails": false,
  "country": "US",
  "currency": "USD",
  "language": "en",
  "sizeType": "US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "Louis Vuitton handbag"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("piotrv1001/vestiaire-collective-listings-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 = {
    "searchQueries": ["Louis Vuitton handbag"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("piotrv1001/vestiaire-collective-listings-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 '{
  "searchQueries": [
    "Louis Vuitton handbag"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call piotrv1001/vestiaire-collective-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vestiaire Collective Listings Scraper",
        "description": "The Vestiaire Collective Scraper extracts product listings and enriched profiles from Vestiaire Collective, capturing names, brands, models, prices, conditions, materials, measurements, seller profiles, and images — ideal for luxury resale price tracking and market research.",
        "version": "0.0",
        "x-build-id": "93mm4XQxxYVKLQgnj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/piotrv1001~vestiaire-collective-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-piotrv1001-vestiaire-collective-listings-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/piotrv1001~vestiaire-collective-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-piotrv1001-vestiaire-collective-listings-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/piotrv1001~vestiaire-collective-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-piotrv1001-vestiaire-collective-listings-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Free-text search terms (e.g. brand or model names). Each query is scraped as its own search, capped at ~1,020 listings per query by the site. Leave empty to browse by filters only.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "filters": {
                        "title": "Catalog filters",
                        "type": "object",
                        "description": "Vestiaire Collective catalog filters keyed by facet id, applied to every search. Example: {\"categoryLvl0.id\": [\"5\"], \"categoryLvl1.id\": [\"59\"], \"universe.id\": [\"1\"]} for Women > Bags > Handbags. IDs come from the site's category facets.",
                        "default": {}
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "priceAsc",
                            "priceDesc",
                            "mostRecent",
                            "popularity"
                        ],
                        "type": "string",
                        "description": "Result ordering used by the search API.",
                        "default": "relevance"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of unique listings to scrape across all search queries.",
                        "default": 50
                    },
                    "fetchProductDetails": {
                        "title": "Fetch product details",
                        "type": "boolean",
                        "description": "Enrich every listing with the product-detail API (measurements, condition, material, full image set, pricing breakdown, full seller profile). Adds cheap plain-HTTP requests per listing.",
                        "default": false
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "ISO country code for localized pricing and availability.",
                        "default": "US"
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Currency code for prices.",
                        "default": "USD"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code for localized text.",
                        "default": "en"
                    },
                    "sizeType": {
                        "title": "Size type",
                        "type": "string",
                        "description": "Size system for size facets (e.g. US, FR, IT).",
                        "default": "US"
                    },
                    "siteId": {
                        "title": "Site ID (advanced)",
                        "type": "integer",
                        "description": "Override the Vestiaire site id used by the product-detail API. Leave empty to derive it from the country (US = 5)."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are recommended to reliably clear Cloudflare on the listing API.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
