# Rebag Scraper (`crawlerbros/rebag-scraper`) Actor

Scrape Rebag - luxury pre-owned handbag, jewelry and watch marketplace. Search by keyword, brand, category, condition and price range, or fetch specific listings by product handle.

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

## Pricing

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

## Rebag Scraper

Scrape **Rebag** — the luxury pre-owned handbag, jewelry and watch resale marketplace — without any API keys or authentication. Extract detailed product data including brand, condition, price, materials, dimensions, photos, and more.

### What is Rebag?

[Rebag](https://www.rebag.com/) is a leading luxury resale platform specializing in pre-owned designer handbags, jewelry, watches, shoes, and accessories from top luxury brands including Louis Vuitton, Chanel, Hermès, Gucci, Prada, and many more. All items are expertly authenticated by Rebag's team before listing.

### Features

- **Search by keyword** — find any luxury item by brand name, model, or keyword
- **Filter by brand** — narrow to specific designers (Louis Vuitton, Chanel, Hermès, etc.)
- **Filter by category** — Bags, Jewelry, Watches, Shoes, Accessories, Apparel
- **Filter by condition** — Never Worn, Excellent, Very Good, Good, Great, Fair, Outlet
- **Price range filtering** — set min/max price in USD
- **Fetch by slug** — retrieve specific listings by their product handle
- **Full product details** — brand, model, condition details, materials, colors, dimensions, accessories included

### Input

| Parameter | Type | Description |
|-----------|------|-------------|
| `mode` | Select | `searchProducts` or `getBySlug` (required) |
| `query` | String | Keyword search (e.g. "louis vuitton", "chanel classic") |
| `brand` | Select | Filter by luxury brand |
| `category` | Select | Filter by product category (Bags, Jewelry, Watches, etc.) |
| `condition` | Select | Filter by item condition |
| `minPrice` | Integer | Minimum price in USD |
| `maxPrice` | Integer | Maximum price in USD |
| `slugs` | Array | Product handle slugs for `getBySlug` mode |
| `maxItems` | Integer | Maximum records to return (default 100) |

### Output

Each record contains:

```json
{
  "id": 9038452621489,
  "slug": "handbags-louis-vuitton-pochette-metis-monogram-empreinte-leather-4355091",
  "title": "Pochette Metis Monogram Empreinte Leather",
  "brand": "Louis Vuitton",
  "model": "Pochette Metis Monogram Empreinte Leather",
  "category": "Cross body bags",
  "condition": "Very good",
  "conditionDetails": "Very good. Exterior: corner wear, scuffs | Handles/Straps: creases",
  "price": 4355.00,
  "isAvailable": true,
  "exteriorMaterial": "Leather",
  "interiorMaterial": "Fabric",
  "exteriorColor": "Neutral",
  "interiorColor": "Neutral",
  "hardwareColor": "Gold",
  "itemNumber": "435509/1",
  "accessories": ["With Strap"],
  "dimensions": {
    "height": 7.5,
    "width": 9.5,
    "depth": 3.0,
    "handleDropInches": 1.0,
    "strapDropInches": "10-18"
  },
  "photos": [
    "https://cdn.shopify.com/s/files/1/0384/0161/files/img1.jpg"
  ],
  "hasAuthenticity": true,
  "productUrl": "https://shop.rebag.com/products/handbags-louis-vuitton-...",
  "sourceUrl": "https://shop.rebag.com/products/handbags-louis-vuitton-...",
  "publishedAt": "2026-05-30T03:59:11-04:00",
  "listedAt": "2026-05-29T13:25:10-04:00",
  "recordType": "luxuryItem",
  "scrapedAt": "2026-05-30T12:00:00+00:00"
}
````

### Use Cases

- **Luxury resale market research** — track pricing trends across brands and categories
- **Brand monitoring** — see all pre-owned inventory for specific designers
- **Investment tracking** — monitor resale values for luxury goods
- **Competitive analysis** — compare authenticated luxury goods marketplace data
- **Price alerting** — find deals by filtering condition and price range

### FAQ

**Does this require an API key?**
No. Rebag's product catalog is publicly accessible via their Shopify-powered storefront. No authentication required.

**Is there a rate limit?**
The scraper uses polite request delays (0.2–0.3 seconds between requests) to stay within acceptable usage limits.

**What brands are available?**
Rebag carries 100+ luxury brands. The most popular include Louis Vuitton, Chanel, Hermès, Gucci, Prada, Balenciaga, Saint Laurent, Celine, Bottega Veneta, Dior, Fendi, Cartier, Rolex, and many more.

**What condition grades does Rebag use?**
Rebag uses: Never Worn, Excellent, Very Good, Good, Great, Fair, and Outlet (clearance pricing).

**Can I search for items with authenticity cards?**
Yes — filter by keyword (e.g., include "authenticity" in query) or check the `hasAuthenticity` field in results.

**How many items can I scrape?**
Up to 10,000 items per run. Set `maxItems` to control the limit.

### Data Source

Data is sourced from Rebag's public Shopify storefront at `shop.rebag.com`, which exposes product data via the standard Shopify `products.json` and search APIs. No authentication or proxy is required.

# Actor input Schema

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

Operation mode: search for products or fetch specific products by slug/handle.

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

Keyword search query (mode=searchProducts). E.g. 'louis vuitton bag', 'chanel classic'.

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

Filter by luxury brand (mode=searchProducts).

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

Filter by product category (mode=searchProducts).

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

Filter by item condition.

## `minPrice` (type: `integer`):

Only include items priced at or above this value.

## `maxPrice` (type: `integer`):

Only include items priced at or below this value.

## `slugs` (type: `array`):

List of Rebag product handles (slugs) to fetch. E.g. 'handbags-louis-vuitton-neverfull-nm-tote-monogram-giant-embroidered-cotton-mm4241823'.

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

Maximum number of items to return.

## Actor input object example

```json
{
  "mode": "searchProducts",
  "query": "louis vuitton",
  "brand": "",
  "category": "",
  "condition": "",
  "maxItems": 100
}
```

# Actor output Schema

## `items` (type: `string`):

Dataset containing all scraped Rebag luxury items.

# 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": "searchProducts",
    "query": "louis vuitton",
    "brand": "",
    "category": "",
    "condition": "",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/rebag-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": "searchProducts",
    "query": "louis vuitton",
    "brand": "",
    "category": "",
    "condition": "",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/rebag-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": "searchProducts",
  "query": "louis vuitton",
  "brand": "",
  "category": "",
  "condition": "",
  "maxItems": 100
}' |
apify call crawlerbros/rebag-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Rebag Scraper",
        "description": "Scrape Rebag - luxury pre-owned handbag, jewelry and watch marketplace. Search by keyword, brand, category, condition and price range, or fetch specific listings by product handle.",
        "version": "1.0",
        "x-build-id": "IzEgNE6JZPv0Potz6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~rebag-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-rebag-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~rebag-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-rebag-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~rebag-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-rebag-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": [
                            "searchProducts",
                            "getBySlug"
                        ],
                        "type": "string",
                        "description": "Operation mode: search for products or fetch specific products by slug/handle.",
                        "default": "searchProducts"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword search query (mode=searchProducts). E.g. 'louis vuitton bag', 'chanel classic'."
                    },
                    "brand": {
                        "title": "Brand",
                        "enum": [
                            "",
                            "louis-vuitton",
                            "chanel",
                            "gucci",
                            "hermes",
                            "prada",
                            "balenciaga",
                            "saint-laurent",
                            "celine",
                            "bottega-veneta",
                            "dior",
                            "fendi",
                            "givenchy",
                            "valentino",
                            "burberry",
                            "loewe",
                            "alexander-mcqueen",
                            "chloe",
                            "goyard",
                            "bvlgari",
                            "cartier",
                            "van-cleef-arpels",
                            "tiffany-co",
                            "omega",
                            "rolex",
                            "tudor"
                        ],
                        "type": "string",
                        "description": "Filter by luxury brand (mode=searchProducts).",
                        "default": ""
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "all-bags",
                            "all-jewelry",
                            "all-watches",
                            "all-shoes",
                            "all-accessories",
                            "all-apparel"
                        ],
                        "type": "string",
                        "description": "Filter by product category (mode=searchProducts).",
                        "default": ""
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "",
                            "Never Worn",
                            "Excellent",
                            "Very Good",
                            "Good",
                            "Great",
                            "Fair",
                            "Outlet"
                        ],
                        "type": "string",
                        "description": "Filter by item condition.",
                        "default": ""
                    },
                    "minPrice": {
                        "title": "Min price (USD)",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Only include items priced at or above this value."
                    },
                    "maxPrice": {
                        "title": "Max price (USD)",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Only include items priced at or below this value."
                    },
                    "slugs": {
                        "title": "Product slugs/handles (mode=getBySlug)",
                        "type": "array",
                        "description": "List of Rebag product handles (slugs) to fetch. E.g. 'handbags-louis-vuitton-neverfull-nm-tote-monogram-giant-embroidered-cotton-mm4241823'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of items to return.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
