# Vestiaire Collective Scraper (`solidcode/vestiairecollective-scraper`) Actor

\[💰 $15 / 1K] Extract pre-owned luxury fashion listings from Vestiaire Collective: brand, price, discount, condition, size, color, category, seller, and photos. Search by keyword with brand, category, condition, price, and sort filters, or paste any search, category, or product URL.

- **URL**: https://apify.com/solidcode/vestiairecollective-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Vestiaire Collective Scraper

Pull live pre-owned luxury fashion listings from Vestiaire Collective at scale — brand, current and original price, computed discount, condition grade, size, color, material, seller trust signals, and full photo galleries for bags, clothing, shoes, watches, jewelry, and accessories from Chanel, Gucci, Louis Vuitton, Hermès, Prada, and thousands more. Built for resale pricing analysts, luxury resellers, and market researchers who need fresh Vestiaire pricing and inventory data without manually browsing the marketplace listing by listing.

### Why This Scraper?

- **6 product categories, Women / Men / Kids** — Bags, Clothing, Shoes, Watches, Jewelry, and Accessories, each resolved across every gender universe so a single search sweeps the whole catalog.
- **5 condition grades, Never-worn-with-tag to Fair** — filter to exactly the wear level you sell or research: Never worn with tag, Never worn, Very good, Good, or Fair.
- **Original price + computed discount percentage on every listing** — current price, the original listed price, and the discount percent are returned side by side, ready for repricing and margin math.
- **Full seller trust profile** — seller name, country, rating, and trust badges on every row, so you can weight listings by seller reputation.
- **Up to 12-image galleries per item** — the complete photo set, plus condition spec sheet and material, when full detail is enabled.
- **Multi-currency pricing** — request prices in EUR, USD, GBP, AUD, CAD, CHF, JPY, and 5 more, wherever Vestiaire supports the currency.
- **Up to ~10,000 listings per search** — paginate to the marketplace's own ceiling on any single query, with editorial-pick and sold flags on each item.
- **Any search, category, or product URL accepted** — paste a Vestiaire link and the type is auto-detected, or type a plain-text keyword and the actor builds the search for you.

### Use Cases

**Resale Pricing & Repricing**
- Benchmark your asking prices against live Vestiaire listings for the same brand and model
- Track discount percentages across condition grades to set competitive prices
- Watch sold flags to learn what actually moves at which price point
- Pull original-vs-current price spreads to model depreciation by brand

**Market & Trend Research**
- Map inventory volume by brand, category, and gender universe
- Compare price distributions across Chanel, Gucci, Louis Vuitton, Hermès, and Prada
- Surface editorial-pick listings to read which pieces the marketplace is promoting
- Measure how condition grade shifts median price within a category

**Brand & Authentication Monitoring**
- Monitor how a specific brand's listings are priced and described over time
- Collect material and condition spec sheets to support authentication workflows
- Track listing volume spikes that signal a flood of a particular item

**Inventory Sourcing**
- Find underpriced items in target brands and price bands to resell
- Filter to Never-worn-with-tag stock for deadstock sourcing
- Build shortlists by category, size, and color for buyers

**Competitive Intelligence**
- Profile high-volume sellers by country, rating, and badge mix
- Compare your catalog against the live market by brand and price range
- Feed structured listing data into dashboards, pricing models, and alerting systems

### Getting Started

#### Simple keyword search

Just type what you're looking for — the actor builds the search:

```json
{
    "searchQueries": ["chanel flap bag"],
    "maxResults": 100
}
````

#### Brand, category, and price filters

Restrict to named brands, categories, and a price band:

```json
{
    "searchQueries": ["loafers"],
    "brands": ["Gucci"],
    "categories": ["shoes"],
    "priceMin": 200,
    "priceMax": 600,
    "conditions": ["never_worn", "very_good"],
    "currency": "USD",
    "maxResults": 300
}
```

#### Paste URLs with full detail and sorting

Paste any Vestiaire search, category, or product URL, enrich each item, and sort:

```json
{
    "startUrls": [
        "https://www.vestiairecollective.com/search/?q=hermes%20kelly",
        "https://www.vestiairecollective.com/women-bags/"
    ],
    "includeItemDetails": true,
    "sortBy": "price_asc",
    "currency": "GBP",
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Vestiaire Collective URLs — search, category, or individual product pages. The type is detected automatically. When you use URLs, the filters below are ignored: everything comes from the URL itself. |
| `searchQueries` | string\[] | `[]` | Plain-text keyword searches, e.g. "chanel flap bag" or "gucci loafers". The actor builds the search for you. The filters below apply to these searches. |

#### Search Filters

These refine your `searchQueries`. They are ignored when you paste URLs (pasted URLs carry their own filters).

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `brands` | string\[] | `[]` | Restrict to named brands, e.g. "Chanel", "Gucci", "Louis Vuitton". Leave empty for all brands. |
| `categories` | multi-select | `[]` | One or more of: Bags, Clothing, Shoes, Watches, Jewelry, Accessories. Leave empty for all categories. |
| `conditions` | multi-select | `[]` | One or more of 5 grades: Never worn with tag, Never worn, Very good condition, Good condition, Fair condition. Leave empty for all. |
| `priceMin` | integer | — | Only include items at or above this price, in the chosen currency. |
| `priceMax` | integer | — | Only include items at or below this price, in the chosen currency. |
| `sortBy` | select | `Most relevant` | Result order: Most relevant, Newest listed first, Price: low to high, or Price: high to low. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum items per URL or search. Set to 0 for as many as possible. Vestiaire returns at most ~10,000 items per single search — split into narrower searches (by brand, category, or price band) to gather more. The last page is always returned in full, so you may receive slightly more than this number. |
| `includeItemDetails` | boolean | `false` | Open each item's page for the complete spec sheet, full photo gallery, and richer seller statistics. Slower and richer — leave off if basic listing data is enough. |
| `currency` | select | `Euro (EUR)` | Currency for the prices in the results: EUR, USD, GBP, AUD, CAD, CHF, DKK, SEK, HKD, SGD, JPY, or KRW, wherever Vestiaire supports it. |

### Output

One flat row per listing. Here's a representative result with full item details enabled:

```json
{
    "id": "48217734",
    "url": "https://www.vestiairecollective.com/women-bags/handbags/chanel/black-leather-classic-flap-bag-chanel-48217734.shtml",
    "title": "Timeless/Classique leather handbag",
    "description": "Authentic Chanel Classic Flap in black quilted lambskin with gold-tone hardware. Comes with dust bag and authenticity card.",
    "brand": "Chanel",
    "category": "Handbags",
    "categoryPath": ["Women", "Bags", "Handbags"],
    "gender": "Women",
    "condition": "Very good condition",
    "size": "Medium",
    "color": "Black",
    "material": "Leather",
    "likesCount": 134,
    "editorialPick": true,
    "isSold": false,
    "isDirectShipping": true,
    "price": 3450,
    "originalPrice": 4200,
    "discountPercent": 18,
    "currency": "EUR",
    "sellerId": "9912034",
    "sellerName": "luxe_resell_paris",
    "sellerCountry": "FR",
    "sellerRating": "Trusted",
    "sellerBadges": ["expert_seller", "fast_shipper"],
    "images": [
        "https://images.vestiairecollective.com/produit/48217734-1_2.jpg",
        "https://images.vestiairecollective.com/produit/48217734-2_2.jpg"
    ],
    "imageUrl": "https://images.vestiairecollective.com/produit/48217734-1_2.jpg",
    "listedAt": "2026-05-12T09:24:00Z",
    "scrapedAt": "2026-06-29T14:30:00Z"
}
```

Fields marked **(detail only)** populate fully only when `includeItemDetails` is on — `condition`, `material`, the complete `images` gallery, and `sellerRating` are among them. With detail off, you still get core listing data, pricing, and basic seller fields.

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique Vestiaire Collective listing identifier |
| `url` | string | Direct link to the listing |
| `title` | string | Listing title |
| `description` | string | Listing description (richer with detail on) |
| `brand` | string | Brand name, e.g. Chanel, Gucci |
| `category` | string | Item category name |
| `categoryPath` | string\[] | Full category breadcrumb, e.g. \["Women", "Bags", "Handbags"] |
| `gender` | string | Gender universe: Women, Men, or Kids |

#### Item Attributes

| Field | Type | Description |
|-------|------|-------------|
| `condition` | string | Condition grade, e.g. "Very good condition" *(detail only)* |
| `size` | string | Item size as listed |
| `color` | string | Primary color |
| `material` | string | Material, e.g. "Leather" *(detail only)* |
| `likesCount` | number | Number of likes on the listing |
| `editorialPick` | boolean | Whether the marketplace flagged the item as an editorial pick |
| `isSold` | boolean | Whether the item has sold |
| `isDirectShipping` | boolean | Whether the item ships directly from the seller |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Current asking price in the chosen currency |
| `originalPrice` | number | Original listed price, when present |
| `discountPercent` | number | Computed discount from original to current price |
| `currency` | string | Currency code for the prices, e.g. EUR, USD |

#### Seller

| Field | Type | Description |
|-------|------|-------------|
| `sellerId` | string | Unique seller identifier |
| `sellerName` | string | Seller display name |
| `sellerCountry` | string | Seller's country code |
| `sellerRating` | string | Seller rating / trust level *(detail only)* |
| `sellerBadges` | string\[] | Seller trust badges, e.g. expert\_seller, fast\_shipper |

#### Media & Timestamps

| Field | Type | Description |
|-------|------|-------------|
| `images` | string\[] | Full photo gallery, up to 12 images *(complete with detail on)* |
| `imageUrl` | string | Primary listing image |
| `listedAt` | string | ISO timestamp when the item was listed |
| `scrapedAt` | string | ISO timestamp of data extraction |

### Tips for Best Results

- **Start small** — set `maxResults` to 50–100 on your first run to confirm the data matches your needs, then scale up.
- **Split deep searches** — a single search returns up to ~10,000 listings. To go beyond that, run several narrower searches (by brand, category, or price band) and combine the results.
- **Enable detail on a shortlist** — `includeItemDetails` fetches each listing individually, so it's slower and costs more. Filter to a focused set first, then turn it on for the spec sheet, full gallery, and seller rating.
- **Mix queries and URLs in one run** — combine plain-text `searchQueries` with pasted Vestiaire URLs to cover several angles at once.
- **Set the currency to your market** — request prices in your selling currency so the price, original price, and discount fields are directly comparable.
- **Use condition grades to segment** — filter to Never-worn-with-tag for deadstock sourcing, or compare median price across grades to map depreciation.
- **Sort by Price: low to high for sourcing** — surface the cheapest matching listings first when hunting for underpriced inventory to resell.

### Pricing

**From $15 per 1,000 results** — pay only for the listings you collect, billed per result. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $1.80 | $1.70 | $1.60 | $1.50 |
| 1,000 | $18 | $17 | $16 | $15 |
| 10,000 | $180 | $170 | $160 | $150 |
| 100,000 | $1,800 | $1,700 | $1,600 | $1,500 |

A "result" is any listing row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom integrations on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate resale pricing analysis, market research, and inventory sourcing. Users are responsible for complying with applicable laws and Vestiaire Collective's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose, and handle any personal data, including seller information, responsibly and in line with applicable privacy regulations.

# Actor input Schema

## `startUrls` (type: `array`):

Paste one or more Vestiaire Collective URLs — search results, category pages, or single product pages. The type is detected automatically. When you use URLs, the search filters below are ignored: everything comes from the URL itself.

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

Type what you are looking for in plain words, e.g. 'chanel flap bag' or 'gucci loafers'. The actor builds the search for you — no need to construct a URL. The filters below apply to these searches.

## `brands` (type: `array`):

Only include items from these brands, e.g. 'Chanel', 'Gucci', 'Louis Vuitton'. Leave empty for all brands. Applies to Search Queries only — ignored when URLs are provided.

## `categories` (type: `array`):

Limit results to these categories. Leave empty to include all categories.

## `conditions` (type: `array`):

Only include items in these conditions. Leave empty for all conditions.

## `priceMin` (type: `integer`):

Only include items at or above this price (in the chosen currency). Leave empty for no lower bound. Maximum 1,000,000.

## `priceMax` (type: `integer`):

Only include items at or below this price (in the chosen currency). Leave empty for no upper bound. Maximum 1,000,000.

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

Order in which results are collected. Ignored when a pasted URL already includes a sort order.

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

Maximum number of items to collect per URL or search query. Set to 0 for as many as possible. Results come in pages and the last page is always returned in full, so you may receive slightly more than this number. Note: Vestiaire Collective returns at most ~10,000 items per single search — to gather more, split your search into narrower ones (by brand, category, or price range). Tip: start with 50-100 to test, then increase.

## `includeItemDetails` (type: `boolean`):

When on, the actor opens each item's page to collect the complete spec sheet, the full photo gallery, and richer seller statistics. This roughly doubles the work per item, so it is slower and costs more. Leave off if the basic listing data is enough.

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

Currency used for the prices in the results, where Vestiaire Collective supports it.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.vestiairecollective.com/search/?q=chanel%20bag"
  ],
  "searchQueries": [],
  "brands": [],
  "categories": [],
  "conditions": [],
  "sortBy": "relevance",
  "maxResults": 100,
  "includeItemDetails": false,
  "currency": "EUR"
}
```

# Actor output Schema

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

Table of scraped listings with key fields.

# 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 = {
    "startUrls": [
        "https://www.vestiairecollective.com/search/?q=chanel%20bag"
    ],
    "searchQueries": [],
    "brands": [],
    "categories": [],
    "conditions": [],
    "sortBy": "relevance",
    "maxResults": 100,
    "includeItemDetails": false,
    "currency": "EUR"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/vestiairecollective-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 = {
    "startUrls": ["https://www.vestiairecollective.com/search/?q=chanel%20bag"],
    "searchQueries": [],
    "brands": [],
    "categories": [],
    "conditions": [],
    "sortBy": "relevance",
    "maxResults": 100,
    "includeItemDetails": False,
    "currency": "EUR",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/vestiairecollective-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 '{
  "startUrls": [
    "https://www.vestiairecollective.com/search/?q=chanel%20bag"
  ],
  "searchQueries": [],
  "brands": [],
  "categories": [],
  "conditions": [],
  "sortBy": "relevance",
  "maxResults": 100,
  "includeItemDetails": false,
  "currency": "EUR"
}' |
apify call solidcode/vestiairecollective-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vestiaire Collective Scraper",
        "description": "[💰 $15 / 1K] Extract pre-owned luxury fashion listings from Vestiaire Collective: brand, price, discount, condition, size, color, category, seller, and photos. Search by keyword with brand, category, condition, price, and sort filters, or paste any search, category, or product URL.",
        "version": "1.0",
        "x-build-id": "CZ1o6tgy5afijOUz6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~vestiairecollective-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-vestiairecollective-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/solidcode~vestiairecollective-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-vestiairecollective-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/solidcode~vestiairecollective-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-vestiairecollective-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": {
                    "startUrls": {
                        "title": "Vestiaire Collective URLs",
                        "type": "array",
                        "description": "Paste one or more Vestiaire Collective URLs — search results, category pages, or single product pages. The type is detected automatically. When you use URLs, the search filters below are ignored: everything comes from the URL itself.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Type what you are looking for in plain words, e.g. 'chanel flap bag' or 'gucci loafers'. The actor builds the search for you — no need to construct a URL. The filters below apply to these searches.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "brands": {
                        "title": "Brands",
                        "type": "array",
                        "description": "Only include items from these brands, e.g. 'Chanel', 'Gucci', 'Louis Vuitton'. Leave empty for all brands. Applies to Search Queries only — ignored when URLs are provided.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Limit results to these categories. Leave empty to include all categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "bags",
                                "clothing",
                                "shoes",
                                "watches",
                                "jewelry",
                                "accessories"
                            ],
                            "enumTitles": [
                                "Bags",
                                "Clothing",
                                "Shoes",
                                "Watches",
                                "Jewelry",
                                "Accessories"
                            ]
                        }
                    },
                    "conditions": {
                        "title": "Condition",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include items in these conditions. Leave empty for all conditions.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "never_worn_with_tag",
                                "never_worn",
                                "very_good",
                                "good",
                                "fair"
                            ],
                            "enumTitles": [
                                "Never worn, with tag",
                                "Never worn",
                                "Very good condition",
                                "Good condition",
                                "Fair condition"
                            ]
                        }
                    },
                    "priceMin": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Only include items at or above this price (in the chosen currency). Leave empty for no lower bound. Maximum 1,000,000."
                    },
                    "priceMax": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Only include items at or below this price (in the chosen currency). Leave empty for no upper bound. Maximum 1,000,000."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "recency",
                            "price_asc",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "Order in which results are collected. Ignored when a pasted URL already includes a sort order.",
                        "default": "relevance"
                    },
                    "maxResults": {
                        "title": "Max results per URL or search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of items to collect per URL or search query. Set to 0 for as many as possible. Results come in pages and the last page is always returned in full, so you may receive slightly more than this number. Note: Vestiaire Collective returns at most ~10,000 items per single search — to gather more, split your search into narrower ones (by brand, category, or price range). Tip: start with 50-100 to test, then increase.",
                        "default": 100
                    },
                    "includeItemDetails": {
                        "title": "Include full item details",
                        "type": "boolean",
                        "description": "When on, the actor opens each item's page to collect the complete spec sheet, the full photo gallery, and richer seller statistics. This roughly doubles the work per item, so it is slower and costs more. Leave off if the basic listing data is enough.",
                        "default": false
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "EUR",
                            "USD",
                            "GBP",
                            "AUD",
                            "CAD",
                            "CHF",
                            "DKK",
                            "SEK",
                            "HKD",
                            "SGD",
                            "JPY",
                            "KRW"
                        ],
                        "type": "string",
                        "description": "Currency used for the prices in the results, where Vestiaire Collective supports it.",
                        "default": "EUR"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
