# WGACA Luxury Vintage Resale Scraper (`crawlerbros/wgaca-scraper`) Actor

Scrape What Goes Around Comes Around (WGACA) - a luxury vintage/pre-owned designer resale retailer. Search by brand or keyword, or browse by category (bags, jewelry, accessories, men's). Get product name, brand, price, condition, material, gender, stock status, and images.

- **URL**: https://apify.com/crawlerbros/wgaca-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## WGACA Luxury Vintage Resale Scraper

Scrape [What Goes Around Comes Around (WGACA)](https://www.whatgoesaroundnyc.com) — a well-known luxury vintage and pre-owned designer resale retailer — without any login, API key, or cookies. Search by brand or keyword, or browse by category, to get product name, brand, price, condition, material, gender, stock status, and images.

### Data source note

This actor originally targeted a different secondhand-fashion marketplace, but that site's product-search endpoint consistently blocked every automated request regardless of query or filters. Per this project's zero-cost reliability policy, it was replaced with **What Goes Around Comes Around (WGACA)** — a genuine luxury vintage/pre-owned resale retailer in the same category with a fully public, unauthenticated product catalog.

### What this actor does

- **Search mode** — free-text search by brand or keyword (e.g. `Chanel`, `Hermes Birkin`, `Cartier Love bracelet`)
- **Browse mode** — walk a top-level category: Bags, Accessories, Jewelry & Watches, Men's, or The Edits (curated picks)
- **Server-side refinements** — price range, condition, gender, color, and store location filters applied at the source
- **No login, API key, cookies, or paid proxy required** — reads WGACA's public product listing pages only
- Empty fields are omitted — never returned as `null` or placeholder text

### Output per product

- `productId` — WGACA's internal product identifier
- `productName` — product title/name
- `brand` — designer/brand name (e.g. `Chanel`, `Hermes`)
- `sourceUrl` — direct link to the product page on whatgoesaroundnyc.com
- `imageUrl` — primary product image
- `imageUrlSecondary` — secondary/alternate product image, when available
- `price` — current listed price
- `currency` — presentment currency (USD by default)
- `condition` — WGACA's condition grade (`Pristine`, `Excellent`, `Very Good`, `Good`)
- `material` — primary material (e.g. `Leather`, `Canvas`, `Gold`)
- `gender` — `Women` or `Men`, when specified
- `discountAmount` — markdown amount off original price, when the item is on sale
- `inStock` — boolean stock availability
- `recordType` — always `"product"`
- `scrapedAt` — ISO timestamp of when the record was collected

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` (by brand/keyword) or `byCategory` (browse) |
| `searchQuery` | string | `Chanel` | Brand name or keyword (mode=search) |
| `category` | string | `bags` | `bags` / `accessories` / `jewelry` / `Men` / `the-edits` (mode=byCategory) |
| `minPrice` | number | – | Drop products priced below this (USD) |
| `maxPrice` | number | – | Drop products priced above this (USD) |
| `condition` | string | – | `Pristine` / `Excellent` / `Very Good` / `Good`. Blank = any |
| `gender` | string | – | `Women` / `Men`. Blank = any |
| `brand` | string | – | Narrow a category browse to one designer (substring match), e.g. `Gucci` |
| `color` | string | – | Server-side color refinement, e.g. `Black`, `Beige`, `Gold`. Blank = any |
| `location` | string | – | Only keep products listed under this WGACA store location — `Beverly Hills`, `Online Only`, `Soho`, `Wooster`. Blank = any |
| `inStockOnly` | boolean | `false` | Only emit products currently marked in stock |
| `maxItems` | integer | `30` | Hard cap on emitted product records (1–300) |

#### Example: search by brand

```json
{
  "mode": "search",
  "searchQuery": "Hermes Birkin",
  "condition": "Excellent",
  "maxItems": 50
}
````

#### Example: browse a category with price and stock filters

```json
{
  "mode": "byCategory",
  "category": "bags",
  "brand": "Chanel",
  "minPrice": 2000,
  "maxPrice": 8000,
  "inStockOnly": true,
  "maxItems": 100
}
```

#### Example: color and location refinement

```json
{
  "mode": "byCategory",
  "category": "jewelry",
  "color": "Gold",
  "location": "Online Only",
  "gender": "Women",
  "maxItems": 40
}
```

### Use cases

- Secondhand/luxury-resale market research and price monitoring
- Sustainability and resale-trend tracking for designer fashion
- Competitive pricing research for thrift/consignment resellers
- Tracking new arrivals and stock changes for specific brands or categories
- Feeding luxury-resale price data into personal shopping or price-alert tools
- Building datasets for fashion-resale value and depreciation analysis

### FAQ

**Do I need to log in or provide an API key?**
No. This actor reads WGACA's public product listing pages only.

**What is WGACA?**
What Goes Around Comes Around is a long-established luxury vintage and pre-owned designer resale retailer, selling authenticated secondhand items from brands like Chanel, Hermès, Cartier, and Louis Vuitton.

**What currency are prices in?**
Prices reflect WGACA's presentment currency for the request (USD by default on Apify's US datacenter proxy).

**Does this include full product descriptions or measurements?**
This actor returns catalog/listing-level fields (name, brand, price, condition, material, images). Extended product-page copy such as fit notes and full measurements is out of scope.

**What does "condition" mean on WGACA listings?**
WGACA grades each pre-owned item — `Pristine`, `Excellent`, `Very Good`, or `Good` — reflecting its physical state. This is set by WGACA, not by the actor.

**Can I filter to only in-stock items?**
Yes — set `inStockOnly` to `true` to drop sold-out or unavailable products from the results.

**Can I search for a specific brand within a category?**
Yes — in `byCategory` mode, use the `brand` field to narrow results to a single designer via substring match (e.g. `brand: "Gucci"` while browsing Bags).

**Does this cover men's items?**
Yes — use `category: "Men"` to browse the men's collection, or set `gender: "Men"` to filter results in search mode.

**How many products can I get in one run?**
Up to 300 per run via `maxItems`. Run multiple times with different search queries or categories to cover more of the catalog.

**Is a proxy required?**
No — this actor works without any paid proxy or residential IP.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

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

Brand name or keyword, e.g. `Chanel`, `Hermes Birkin`, `Cartier Love bracelet`.

## `category` (type: `string`):

Top-level product category.

## `minPrice` (type: `number`):

Drop products priced below this.

## `maxPrice` (type: `number`):

Drop products priced above this.

## `condition` (type: `string`):

Only keep products in this condition. Leave blank for all conditions.

## `gender` (type: `string`):

Only keep products for this gender. Leave blank for all.

## `brand` (type: `string`):

Further narrow a category browse to a specific designer brand (substring match), e.g. `Gucci`.

## `color` (type: `string`):

Only keep products in this color (server-side WGACA color refinement). Leave blank for all colors.

## `location` (type: `string`):

Only keep products listed under this WGACA physical/online store location. Leave blank for all locations.

## `inStockOnly` (type: `boolean`):

Only emit products currently marked in stock.

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

Hard cap on emitted product records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "Chanel",
  "category": "bags",
  "condition": "",
  "gender": "",
  "color": "",
  "location": "",
  "inStockOnly": false,
  "maxItems": 30
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped WGACA product records.

# 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 = {
    "mode": "search",
    "searchQuery": "Chanel",
    "category": "bags",
    "condition": "",
    "gender": "",
    "color": "",
    "location": "",
    "inStockOnly": false,
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/wgaca-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 = {
    "mode": "search",
    "searchQuery": "Chanel",
    "category": "bags",
    "condition": "",
    "gender": "",
    "color": "",
    "location": "",
    "inStockOnly": False,
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/wgaca-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 '{
  "mode": "search",
  "searchQuery": "Chanel",
  "category": "bags",
  "condition": "",
  "gender": "",
  "color": "",
  "location": "",
  "inStockOnly": false,
  "maxItems": 30
}' |
apify call crawlerbros/wgaca-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WGACA Luxury Vintage Resale Scraper",
        "description": "Scrape What Goes Around Comes Around (WGACA) - a luxury vintage/pre-owned designer resale retailer. Search by brand or keyword, or browse by category (bags, jewelry, accessories, men's). Get product name, brand, price, condition, material, gender, stock status, and images.",
        "version": "1.0",
        "x-build-id": "nbQ1MyYigGbkTmwtc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~wgaca-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-wgaca-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/crawlerbros~wgaca-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-wgaca-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/crawlerbros~wgaca-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-wgaca-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Brand name or keyword, e.g. `Chanel`, `Hermes Birkin`, `Cartier Love bracelet`.",
                        "default": "Chanel"
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "bags",
                            "accessories",
                            "jewelry",
                            "Men",
                            "the-edits"
                        ],
                        "type": "string",
                        "description": "Top-level product category.",
                        "default": "bags"
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "number",
                        "description": "Drop products priced below this."
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "number",
                        "description": "Drop products priced above this."
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "",
                            "Pristine",
                            "Excellent",
                            "Very Good",
                            "Good"
                        ],
                        "type": "string",
                        "description": "Only keep products in this condition. Leave blank for all conditions.",
                        "default": ""
                    },
                    "gender": {
                        "title": "Gender",
                        "enum": [
                            "",
                            "Women",
                            "Men"
                        ],
                        "type": "string",
                        "description": "Only keep products for this gender. Leave blank for all.",
                        "default": ""
                    },
                    "brand": {
                        "title": "Brand contains (mode=byCategory)",
                        "type": "string",
                        "description": "Further narrow a category browse to a specific designer brand (substring match), e.g. `Gucci`."
                    },
                    "color": {
                        "title": "Color",
                        "enum": [
                            "",
                            "Beige",
                            "Black",
                            "Blue",
                            "Brown",
                            "Burgundy",
                            "Clear",
                            "Cream",
                            "Gold",
                            "Green",
                            "Grey",
                            "Miscellaneous",
                            "Navy",
                            "Orange",
                            "Pink",
                            "Purple",
                            "Red",
                            "Silver",
                            "White",
                            "Yellow"
                        ],
                        "type": "string",
                        "description": "Only keep products in this color (server-side WGACA color refinement). Leave blank for all colors.",
                        "default": ""
                    },
                    "location": {
                        "title": "Store location",
                        "enum": [
                            "",
                            "Beverly Hills",
                            "Online Only",
                            "Soho",
                            "Wooster"
                        ],
                        "type": "string",
                        "description": "Only keep products listed under this WGACA physical/online store location. Leave blank for all locations.",
                        "default": ""
                    },
                    "inStockOnly": {
                        "title": "In stock only",
                        "type": "boolean",
                        "description": "Only emit products currently marked in stock.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Hard cap on emitted product records.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
