# Vestiaire Collective Scraper | Luxury Resale Items (`parseforge/vestiaire-collective-scraper`) Actor

Scrape Vestiaire Collective for pre-owned luxury bags, clothes, shoes, and watches with brand, condition, price, seller, authentication status, photos, and details. Power resale analytics, luxury price tracking, brand intelligence, and secondhand market research projects.

- **URL**: https://apify.com/parseforge/vestiaire-collective-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 👜 Vestiaire Collective Scraper

> 🚀 **Export Vestiaire Collective luxury fashion listings in seconds.** Search by brand, item type, or keyword and download titles, brands, conditions, prices, sizes, and seller data in one structured dataset.

> 🕒 **Last updated:** 2026-05-22 · **📊 18 fields** per record · **Up to 10,000 results per search** · **Global luxury resale coverage**

The Vestiaire Collective Scraper extracts pre-owned luxury fashion listings from Vestiaire Collective - the world's leading curated resale platform for authenticated designer items. It queries the platform's real-time search API and returns a comprehensive dataset including brand, category, condition, size, color, price, discount, seller information, and a direct link to each listing.

Vestiaire Collective hosts millions of authenticated luxury items from brands including Chanel, Louis Vuitton, Gucci, Hermes, Balenciaga, and thousands of others, with sellers from over 80 countries. This scraper gives you structured access to that global inventory for market research, pricing intelligence, or resale operations.

### Target Audience

| Who | Why |
|-----|-----|
| Luxury resellers | Monitor market pricing and identify sourcing opportunities |
| Fashion market researchers | Track brand pricing trends and supply dynamics in the secondary market |
| Authentication and appraisal services | Benchmark fair market values across conditions and sizes |
| Fashion journalists and analysts | Understand which brands and styles are most active in resale |
| Personal shoppers and stylists | Find specific items for clients at competitive prices |

### 📋 What the Vestiaire Collective Scraper does

- Searches Vestiaire Collective's inventory by keyword or brand in real time
- Extracts brand, category, size, condition, color, and price for every listing
- Captures original price and discount when items are reduced
- Collects seller details including name, ID, and official store status
- Translates condition IDs to human-readable labels (Never worn, Very good condition, etc.)
- Paginates up to 10,000 results per search (Vestiaire's API maximum)
- Supports multiple currencies: USD, EUR, GBP, CAD, AUD

> 💡 **Why it matters:** Vestiaire Collective has no public API. This actor is the only way to systematically extract bulk listing data from one of the world's top luxury resale platforms - enabling price intelligence and market analysis at a scale impossible through manual browsing.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `query` | string | `chanel bag` | Search keyword (e.g. "louis vuitton", "hermes belt", "gucci sneakers") |
| `sortBy` | string | `relevance` | Sort order: `relevance`, `price_asc`, `price_desc`, `newest` |
| `currency` | string | `USD` | Currency for prices: USD, EUR, GBP, CAD, AUD |
| `maxItems` | integer | `10` | Maximum number of listings to collect (free: 10, paid: up to 10,000) |

**Example 1 - Search for Louis Vuitton handbags, cheapest first:**
```json
{
  "query": "louis vuitton neverfull",
  "sortBy": "price_asc",
  "currency": "USD",
  "maxItems": 200
}
````

**Example 2 - Browse Hermes items in EUR:**

```json
{
  "query": "hermes birkin",
  "currency": "EUR",
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** Vestiaire Collective's search API caps results at 10,000 items per query. For broader coverage, run multiple targeted searches by brand or category. Currency selection affects displayed prices but does not filter listings. Free users are limited to 10 items per run.

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🖼️ `imageUrl` | string | Main listing photo URL |
| 📝 `title` | string | Listing title as shown on Vestiaire |
| 🏷️ `brand` | string | Brand name (e.g. Chanel, Louis Vuitton, Gucci) |
| 🗂️ `category` | string | Product category (e.g. Handbags, Shoes, Clothing) |
| 📏 `size` | string | Size label as listed |
| 🏷️ `condition` | string | Condition label (Never worn with tag, Never worn, Very good condition, Good condition, Fair condition) |
| 💰 `price` | number | Current asking price |
| 💰 `originalPrice` | number | Original price before discount (null if no discount) |
| 💱 `currency` | string | Currency code |
| 🎨 `color` | string | Primary color |
| 🌍 `country` | string | Seller's country code |
| 👤 `sellerName` | string | Seller's display name |
| 🆔 `sellerId` | string | Seller's internal ID |
| 🏪 `isOfficialStore` | boolean | Whether the seller is a Vestiaire Official Store |
| 🆔 `listingId` | string | Vestiaire Collective's internal listing ID |
| 🔗 `listingUrl` | string | Direct link to the listing |
| ❤️ `likeCount` | number | Number of users who liked this listing |
| ✅ `sold` | boolean | Whether the item has been sold |
| 🕒 `scrapedAt` | string | ISO timestamp of when the record was collected |

**Sample record:**

```json
{
  "imageUrl": "https://images.vestiairecollective.com/cdn-cgi/image/q=75,f=auto/produit/xxl/12345678_12345678.jpg",
  "title": "Chanel Classic Flap Medium Black Caviar Gold Hardware",
  "brand": "Chanel",
  "category": "Handbags",
  "size": "One size",
  "condition": "Very good condition",
  "price": 4800,
  "originalPrice": null,
  "currency": "USD",
  "color": "Black",
  "country": "US",
  "sellerName": "Marie L.",
  "sellerId": "9876543",
  "isOfficialStore": false,
  "listingId": "12345678",
  "listingUrl": "https://us.vestiairecollective.com/women-bags/handbags/chanel/black-leather-chanel-bag-12345678.shtml",
  "likeCount": 47,
  "sold": false,
  "scrapedAt": "2026-05-22T09:15:00.000Z",
  "error": null
}
```

### ✨ Why choose this Actor

- **18 fields per record** - the most comprehensive Vestiaire data extraction available
- **Multi-currency support** - collect prices in USD, EUR, GBP, CAD, or AUD
- **Human-readable conditions** - numeric condition codes translated automatically
- **Official Store flag** - distinguish individual sellers from verified Vestiaire brand stores
- **Discount tracking** - `originalPrice` captured when listings show a reduced price
- **Residential proxies built in** - reliable access without configuration
- **Pay-per-item pricing** - only pay for listings you actually collect

### 📈 How it compares to alternatives

| Feature | ParseForge Vestiaire Scraper | Manual browsing | The RealReal scraper |
|---------|------------------------------|-----------------|---------------------|
| Luxury resale data | Yes | Yes | Different platform |
| Condition labels | Human-readable | Human-readable | Varies |
| Seller details | Yes | Yes | Limited |
| Discount capture | Yes | Yes | Varies |
| Multi-currency | Yes (5 currencies) | Yes | Typically USD |
| Bulk export | Yes, up to 10K | No | N/A |
| Free tier | 10 items | Unlimited (slow) | N/A |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the Vestiaire Collective Scraper actor page and click **Try for free**
3. Enter a search query (e.g. `gucci loafers`, `prada nylon bag`, `ysl wallet`)
4. Choose sort order and currency
5. Set `maxItems` to the number of listings you want
6. Click **Start** - results are typically ready in under 2 minutes
7. Download as CSV, JSON, Excel, or connect via API

### 💼 Business use cases

#### Luxury Resale Pricing Intelligence

Resellers and dealers can monitor how specific brands, models, and conditions are priced across Vestiaire's global marketplace - enabling smarter sourcing and pricing decisions.

#### Authentication and Appraisal Reference

Appraisers and authentication services can pull current market comps for specific items to establish fair market values based on real transaction listings.

#### Fashion Brand Secondary Market Analysis

Luxury brands and brand consultants can track how their products perform in the secondary market - which items retain value, which depreciate, and what condition distribution looks like.

#### Trend and Demand Research

Fashion journalists, stylists, and trend forecasters can monitor which brands and styles have the most active secondary market supply and demand (via `likeCount`).

### 🔌 Automating Vestiaire Collective Scraper

- **Make (formerly Integromat)** - Schedule daily price monitoring runs and log changes to a Google Sheet or Airtable database
- **Zapier** - Trigger alerts when items matching your target brand and price range appear
- **Slack** - Post daily deal summaries for specific brands to a team channel
- **REST API** - Integrate real-time Vestiaire pricing into your own resale or appraisal application

### 🌟 Beyond business use cases

#### Personal Shopping Wishlist Monitoring

Set up automated searches for specific items you're looking for - a particular Chanel bag color, a specific Hermes size - and get notified when new listings appear.

#### Academic Fashion Research

Researchers studying luxury consumption, fashion cycles, or the circular economy can collect systematic data on secondary market supply and pricing across brands and categories.

#### Sustainability and Circular Economy Analysis

Environmental researchers can track the scale and growth of luxury resale as an indicator of circular fashion adoption.

#### Collector Valuation

Collectors of designer items can track market prices over time for their collection and make informed decisions about buying and selling.

### 🤖 Ask an AI assistant about this scraper

Not sure how to analyze your results? Ask an AI:

> "I have a JSON dataset from the Vestiaire Collective Scraper with fields brand, condition, price, originalPrice, and likeCount. How do I find all Chanel items in 'Very good condition' under $3000, sorted by most liked?"

The structured output is designed to work immediately with spreadsheets, databases, and AI analysis tools.

### ❓ Frequently Asked Questions

**What is Vestiaire Collective?**
Vestiaire Collective is a curated global marketplace for pre-owned luxury and designer fashion, founded in Paris in 2009. All items are authenticated by the platform before delivery to buyers.

**Does this scraper require a Vestiaire account?**
No. All data is collected from publicly accessible search results. No login is required.

**What conditions are available?**
Five condition grades: Never worn with tag, Never worn, Very good condition, Good condition, and Fair condition.

**How many results can I collect?**
Vestiaire's search API returns a maximum of 10,000 results per query. For broader coverage, run multiple searches with different keywords or brand names.

**Does it collect sold items?**
Yes - the `sold` field is `true` for items that have been sold. This is useful for tracking what has actually transacted at what price.

**What does `isOfficialStore` mean?**
Some sellers on Vestiaire are verified brand boutiques or official resellers. The `isOfficialStore` flag distinguishes these from individual private sellers.

**Can I filter by brand in the input?**
Use the `query` field with the brand name (e.g. "louis vuitton"). For brand-only results, use just the brand name with no other keywords.

**Can I filter by condition, size, or color?**
Not at the input level. Filter the output data by the `condition`, `size`, or `color` fields after export.

**What currencies are supported?**
USD, EUR, GBP, CAD, and AUD. The currency field in the output confirms which currency each price is in.

**What does `originalPrice` mean?**
When a seller has reduced their listing price, `originalPrice` shows the previous higher price. If no discount has been applied, `originalPrice` is null.

**Is the data real-time?**
Yes. Every run fetches live listings from Vestiaire's search API. No cached data is ever returned.

**Can I collect multiple pages of results?**
Yes. The scraper paginates automatically in batches of 60 until `maxItems` is reached or the 10,000-result API limit is hit.

### 🔌 Integrate with any app

Export your dataset to:

**Spreadsheets:** Google Sheets, Microsoft Excel, Airtable

**Databases:** PostgreSQL, MySQL, MongoDB, Supabase

**E-commerce:** Shopify (via data import), WooCommerce

**Automation:** Make, Zapier, n8n, Pipedream

**Analytics:** Tableau, Power BI, Metabase, Google Looker Studio

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [The RealReal Scraper](https://apify.com/parseforge) | Extract authenticated luxury listings from The RealReal |
| [eBay Scraper](https://apify.com/parseforge) | Scrape active and completed eBay listings for pricing |
| [OfferUp Scraper](https://apify.com/parseforge/offerup-scraper) | Collect local marketplace listings from OfferUp |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 50+ ready-to-use data extractors covering luxury resale, marketplaces, travel, real estate, and more.

***

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA) and we will get back to you within one business day.

***

> **⚠️ Disclaimer:** This actor is an independent tool not affiliated with, endorsed by, or connected to Vestiaire Collective SAS. It accesses only publicly available listing data. Use responsibly and in accordance with Vestiaire Collective's Terms of Service. ParseForge is not responsible for how collected data is used.

# Actor input Schema

## `query` (type: `string`):

Search term for luxury items (e.g. 'chanel bag', 'gucci shoes', 'louis vuitton')

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Sort order for search results

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

Currency for prices

## Actor input object example

```json
{
  "query": "chanel bag",
  "maxItems": 10,
  "sortBy": "relevance",
  "currency": "USD"
}
```

# 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 = {
    "query": "chanel bag",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/vestiaire-collective-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 = {
    "query": "chanel bag",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/vestiaire-collective-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 '{
  "query": "chanel bag",
  "maxItems": 10
}' |
apify call parseforge/vestiaire-collective-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vestiaire Collective Scraper | Luxury Resale Items",
        "description": "Scrape Vestiaire Collective for pre-owned luxury bags, clothes, shoes, and watches with brand, condition, price, seller, authentication status, photos, and details. Power resale analytics, luxury price tracking, brand intelligence, and secondhand market research projects.",
        "version": "0.1",
        "x-build-id": "3mZWabq8FGaH5opap"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~vestiaire-collective-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-vestiaire-collective-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/parseforge~vestiaire-collective-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-vestiaire-collective-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/parseforge~vestiaire-collective-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-vestiaire-collective-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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term for luxury items (e.g. 'chanel bag', 'gucci shoes', 'louis vuitton')"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "price_asc",
                            "price_desc",
                            "createdAt_desc",
                            "likes_desc"
                        ],
                        "type": "string",
                        "description": "Sort order for search results",
                        "default": "relevance"
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "CAD",
                            "AUD"
                        ],
                        "type": "string",
                        "description": "Currency for prices",
                        "default": "USD"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
