# Vestiaire Collective Scraper — Luxury Resale Fashion Data (`studio-amba/vestiairecollective-scraper`) Actor

Scrape Vestiaire Collective for pre-owned luxury fashion: bags, clothing, shoes and accessories with brand, price, condition, size, seller and images.

- **URL**: https://apify.com/studio-amba/vestiairecollective-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 result scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 — Luxury Resale Fashion Data

Scrape [Vestiaire Collective](https://www.vestiairecollective.com), Europe's
largest pre-owned luxury fashion marketplace, into clean structured data.
Search by brand or item and get price, condition, size, seller and images for
every result — bags, clothing, shoes, jewellery and accessories, women's,
men's and kids'.

Vestiaire Collective lists hundreds of thousands of pre-owned designer items
across hundreds of brands. This actor reads their own search index directly
and returns one row per item, no login required.

### What you get

One row per item, with:

- Price and currency (as listed), condition (e.g. "Très bon état"), size and
  colour where the item has them
- Seller name, seller badge (e.g. "Expert") and whether it's an official
  brand/store account
- Sold status and seller-marked stock status
- Full seller description, all item images and the source URL

### Who it is for

- Resale platforms and pricing tools tracking secondhand designer prices
  across marketplaces
- Market-intelligence and fashion-resale researchers comparing brand-level
  resale values over time
- Authentication and valuation services that need comparable listing data
- Sellers and buyers benchmarking a specific bag, brand or style against
  current asking prices

### How to scrape Vestiaire Collective data

1. Set **Search query** to a brand (e.g. `Chanel`, `Gucci`, `Hermes`) or an
   item type. This matches Vestiaire Collective's own search box.
2. Optionally restrict to **Universe**: Women, Men or Kids.
3. Set **Max results** to cap the run. Vestiaire Collective's own search API
   caps deep pagination at roughly 1,200 reachable results per distinct
   query — narrow the search query (a more specific brand or item) to reach
   deeper into a niche rather than raising this above the cap.
4. Run the actor. Results stream into the dataset and can be exported as
   JSON, CSV or Excel.

#### Example inputs

Chanel bags and clothing, all genders:

```json
{
  "searchQuery": "Chanel",
  "maxResults": 200
}
```

Gucci, men's only:

```json
{
  "searchQuery": "Gucci",
  "universe": "men",
  "maxResults": 250
}
```

Hermès, women's only, small sample:

```json
{
  "searchQuery": "Hermes",
  "universe": "women",
  "maxResults": 50
}
```

### Input reference

| Field | Type | Description |
|---|---|---|
| `searchQuery` | string | Free-text search — a brand or item type. Default `Chanel`. |
| `universe` | select | `women`, `men` or `kids`. Empty = all. |
| `maxResults` | integer | Stop after this many items. Default 100, max 1200 (the site's own API pagination limit per search). |
| `proxyConfiguration` | object | RESIDENTIAL + country FR, required (see below). |

### Output fields

| Field | Type | Example |
|---|---|---|
| `productId` | string | `"70036500"` |
| `name` | string | `"Besace en cuir"` |
| `brand` | string | `"Chanel"` |
| `price` | number | null | `1575` |
| `currency` | string | null | `"EUR"` |
| `condition` | string | null | `"Très bon état"` |
| `size` | string | null | `"42 FR"` (null for items with no size, e.g. most bags) |
| `color` | string | null | `"Beige"` |
| `sold` | boolean | `false` |
| `inStock` | boolean | null | `true` — null only when the source doesn't expose it |
| `sellerId` | string | null | `"9742869"` |
| `sellerName` | string | null | `"maria"` |
| `sellerBadge` | string | null | `"Expert"` |
| `isOfficialStore` | boolean | `false` |
| `itemCountry` | string | null | `"PT"` |
| `likes` | number | null | `10` |
| `description` | string | null | Full seller description |
| `imageUrl` | string | null | First item image |
| `imageUrls` | array | All item images |
| `universe` | string | null | `"women"` |
| `createdAt` | string | null | ISO 8601 — when the item was listed |
| `url` | string | Full item URL |
| `source` | string | `"vestiairecollective.com"` |
| `scrapedAt` | string | ISO 8601 timestamp |
| `searchQuery` | string | null | Search query input echo |

#### Example output

```json
{
  "productId": "70036500",
  "name": "Besace en cuir",
  "brand": "Chanel",
  "price": 1575,
  "currency": "EUR",
  "condition": "Très bon état",
  "size": null,
  "color": "Beige",
  "sold": false,
  "inStock": false,
  "sellerId": "9742869",
  "sellerName": "maria",
  "sellerBadge": "Expert",
  "isOfficialStore": false,
  "itemCountry": "PT",
  "likes": 10,
  "description": "Un sac à main Chanel classique en très bon état. Utilisé seulement quelques fois.",
  "imageUrl": "https://images.vestiairecollective.com/produit/70036500-1_3.jpg",
  "imageUrls": ["https://images.vestiairecollective.com/produit/70036500-1_3.jpg"],
  "universe": "women",
  "createdAt": "2026-08-20T01:48:50.000Z",
  "url": "https://www.vestiairecollective.com/sacs-femme/sacs-a-main/chanel/sac-a-main-chanel-en-cuir-beige-70036500.shtml",
  "source": "vestiairecollective.com",
  "scrapedAt": "2026-08-20T09:21:44.847Z",
  "searchQuery": "Chanel"
}
```

### Proxy

RESIDENTIAL + country FR is required. Vestiaire Collective sits behind a
Cloudflare managed challenge on every route, including its own search API —
plain HTTP and Apify's automatic proxy pool both get blocked. The actor
warms up a real browser session through a French residential IP once per run
to pass the challenge, then reuses that session for fast plain-HTTP calls to
the search API. Keep the proxy on RESIDENTIAL + FR; switching it off will
make every run fail.

### Cost

Pricing is pay per result. One browser warm-up per run passes the Cloudflare
challenge; every result after that is a cheap HTTP call, no per-item browser
overhead. A run's usage cost only settles after it reports SUCCEEDED — a
dataset read taken mid-run shows a cost far below the final figure, so size
your spend from a completed run, not a partial one.

### Limitations

- Vestiaire Collective's own search API caps deep pagination at ~1,200
  reachable results per distinct (query, universe) combination — this is
  their limit, not the actor's. Narrow the search query for more coverage of
  a niche.
- `size` is null for items that don't have one (most bags, jewellery,
  accessories) — this is expected, not missing data.
- `price` reflects the current asking price at scrape time and can change as
  sellers adjust it or the item sells.
- Data is scraped from the public search index and may change without
  notice.

### Related scrapers

- [Vinted Scraper](https://apify.com/studioamba/vinted-scraper) — secondhand
  fashion, electronics and home items across Vinted's EU country sites
- [Mytheresa Scraper](https://apify.com/studioamba/mytheresa-scraper) —
  full-price luxury e-tail with per-size stock
- [Off-White Scraper](https://apify.com/studioamba/off-white-scraper) —
  brand-direct Off-White catalogue
- [Miu Miu Scraper](https://apify.com/studioamba/miu-miu-scraper) —
  brand-direct Miu Miu catalogue

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API — maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text search — a brand (e.g. 'Chanel', 'Gucci', 'Hermes') or an item type (e.g. 'sac a main'). Matches Vestiaire Collective's own search box. Leave empty to use the default 'Chanel'.

## `universe` (type: `string`):

Restrict results to Women, Men or Kids. Leave empty for all.

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

Stop after this many items. Vestiaire Collective's search API caps deep pagination at ~1,200 reachable results per distinct search query (their own offset limit) — narrow the search query for more coverage of a specific niche.

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

RESIDENTIAL + country FR is required. Vestiaire Collective sits behind a Cloudflare managed challenge on every route, including its own search API (see docs/site-recon/vestiairecollective.md) — a French residential IP through a real browser (Camoufox) is the only route that passes it, and the resulting session is IP-scoped so every follow-up request must stay on the same residential exit. Do not switch this off.

## Actor input object example

```json
{
  "searchQuery": "Chanel",
  "universe": "",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# 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 = {
    "searchQuery": "Chanel",
    "universe": "",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/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 = {
    "searchQuery": "Chanel",
    "universe": "",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/vestiairecollective-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "Chanel",
  "universe": "",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call studio-amba/vestiairecollective-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/vestiairecollective-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/qeAxugye2EdUtEWmV/builds/V5Xho8b4Jnvuxs424/openapi.json