# SwissWatchExpo Pre-Owned Luxury Watch Scraper (`lulzasaur/swisswatchexpo-scraper`) Actor

Scrape pre-owned luxury watches from SwissWatchExpo (Rolex, Omega, Patek Philippe, Cartier & more). Per watch: title, brand, model, reference number, year, serial, condition, box & papers, price, availability, images and URL. Search by keyword or brand catalog URL.

- **URL**: https://apify.com/lulzasaur/swisswatchexpo-scraper.md
- **Developed by:** [lulz bot](https://apify.com/lulzasaur) (community)
- **Categories:** E-commerce
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

## SwissWatchExpo Pre-Owned Luxury Watch Scraper

Scrape **pre-owned luxury watches** from [SwissWatchExpo](https://www.swisswatchexpo.com) — one of the largest online dealers of authenticated second-hand Rolex, Omega, Patek Philippe, Cartier, Breitling, Audemars Piguet, Panerai, Tudor and more.

Search by keyword (e.g. `rolex submariner`, `omega speedmaster`, `nautilus`) or point the scraper at any brand/model catalog URL, and get structured data for every listing — including the full spec sheet from each product page.

### Output fields

| Field | Description |
|-------|-------------|
| `title` | Full listing title, e.g. "Rolex Datejust 41 Steel White Gold Silver Dial Mens Watch 126334 Box Card" |
| `brand` | Watch brand (Rolex, Omega, Patek Philippe, ...) |
| `model` | Model family, e.g. "Datejust 41", "Submariner" |
| `referenceNumber` | Manufacturer reference / model number, e.g. `126334` |
| `year` | Production year |
| `serialNumber` | Partially masked serial, e.g. `A461xxxx` |
| `condition` | Dealer condition statement, e.g. "Excellent condition." |
| `boxPapers` | What's included, e.g. "Rolex box, card, and tag..." |
| `includesBox` / `includesPapers` | Booleans parsed from structured data |
| `price` / `currency` | Asking price in USD |
| `availability` | `In Stock` or `Sold` |
| `gender`, `caliber`, `movement`, `caseSize`, `caseMaterial`, `dialColor`, `braceletType`, `bandMaterial` | Spec details |
| `caseDescription`, `dialDescription`, `braceletDescription` | Full spec-sheet text |
| `warranty` | Dealer warranty, e.g. "18-Month SwissWatchExpo Warranty" |
| `stockNumber` | SwissWatchExpo stock number |
| `image` / `images` | Product photo URLs |
| `url` | Product page URL |

### Example output

```json
{
  "title": "Rolex Datejust 41 Steel White Gold Silver Dial Mens Watch 126334 Box Card",
  "brand": "Rolex",
  "model": "Datejust 41",
  "referenceNumber": "126334",
  "year": "2025",
  "serialNumber": "A461xxxx",
  "condition": "Excellent condition.",
  "boxPapers": "Rolex box, card, and tag. Exclusive SwissWatchExpo Certificate of Authenticity.",
  "includesBox": true,
  "price": 15805,
  "currency": "USD",
  "availability": "In Stock",
  "stockNumber": "82552",
  "url": "https://www.swisswatchexpo.com/watches/rolex-datejust-41-steel-white-gold-silver-dial-mens-watch-126334-box-card-82552/"
}
```

### Input

```json
{
  "searchQueries": ["rolex submariner", "omega speedmaster"],
  "startUrls": [{ "url": "https://www.swisswatchexpo.com/watches/patek-philippe/" }],
  "maxItems": 100,
  "scrapeDetails": true,
  "includeSold": false
}
```

- **searchQueries** — keyword searches against the site catalog.
- **startUrls** — brand or model catalog URLs (e.g. `/watches/rolex/`, `/watches/omega/seamaster/`).
- **scrapeDetails** — visit each product page for the full spec sheet (reference, year, serial, condition, box & papers, caliber...). Turn off for faster title/price-only runs.
- **includeSold** — include recently sold archive listings (sold watches show no price).

### Use cases

- **Market pricing** — track asking prices for specific references (e.g. all Submariner 126610LN listings).
- **Inventory monitoring** — watch for newly listed pieces from a brand or model family.
- **Resale arbitrage** — compare dealer prices against auction and marketplace results.
- **Data products** — build pre-owned watch price indexes and trend dashboards.

### Notes

- Only public listing data is collected. No login is used.
- Prices are USD asking prices set by the dealer.
- Sold/archive listings do not display prices.

# Actor input Schema

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

One or more keyword searches, e.g. 'rolex submariner', 'omega speedmaster', 'patek philippe nautilus', 'daytona'. Each query is run against SwissWatchExpo's catalog search.

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

Optional SwissWatchExpo catalog/brand URLs to scrape instead of (or in addition to) keyword searches, e.g. https://www.swisswatchexpo.com/watches/rolex/ or https://www.swisswatchexpo.com/watches/omega/seamaster/.

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

Maximum number of watches to return across all queries and start URLs combined. Default 40.

## `scrapeDetails` (type: `boolean`):

Visit each watch's product page to extract the full spec sheet: brand, model, reference number, year, serial number, caliber, movement, condition, box & papers, case/dial/bracelet details, all photos. Slower but much richer. Default ON.

## `includeSold` (type: `boolean`):

Also include recently sold archive listings (no price shown for sold watches). Default OFF — only in-stock watches are returned.

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

Proxy settings. SwissWatchExpo serves plain server-rendered HTML and works best with direct access; a proxy is only recommended for very large runs.

## Actor input object example

```json
{
  "searchQueries": [
    "rolex submariner"
  ],
  "startUrls": [],
  "maxItems": 40,
  "scrapeDetails": true,
  "includeSold": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "searchQueries": [
        "rolex submariner"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lulzasaur/swisswatchexpo-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 = {
    "searchQueries": ["rolex submariner"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("lulzasaur/swisswatchexpo-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 '{
  "searchQueries": [
    "rolex submariner"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call lulzasaur/swisswatchexpo-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lulzasaur/swisswatchexpo-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/vkjLFEf4l9E9G7R9m/builds/Q0ZnqIFRbGjQU4ujy/openapi.json