# Chrono24 Scraper — Luxury Watch Listings & Dealer Data (`crawloop/chrono24-scraper`) Actor

Scrape Chrono24 watch listings by keyword, brand, or URL. Export price, reference, condition, box & papers, shipping, seller rating, and specs as JSON for dealers, appraisers, and pricing apps.

- **URL**: https://apify.com/crawloop/chrono24-scraper.md
- **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.79 / 1,000 watch listings

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/actors/running/actors-in-store.md#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

## Chrono24 Scraper — Luxury Watch Listings & Dealer Data

> Unofficial community Actor. Not affiliated with Chrono24.

**Chrono24 scraper** for the world's largest **luxury watch** marketplace. Pull live listings by keyword, brand, model page, or URL — asking price, reference number, condition, box & papers, shipping, seller rating, and full spec sheets — as JSON. Use it as a **Chrono24 API alternative** from Python, Node.js, or MCP. HTTP-first (`curl_cffi`), no browser.

This Actor is **luxury resale**, not a TCG/collectibles suite. For completed sales on another marketplace, pair with [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper).

### When to use

- Monitor **Rolex / Patek / AP** inventory and asking prices across dealers
- Find **undervalued references** (box & papers, certified, private sellers)
- Build a **dealer map**: rating, review count, city, country, Chrono24 Direct vs private
- Feed appraisal, insurance, and grey-market dashboards with typed numeric fields
- Fast **card-only** runs for daily price watches; optional detail fetch for spec sheets

**When not to use:** Chrono24 does not publish a public sold-archive API. This Actor scrapes **live listings**, not historical sold prices.

### Key features

- **Keywords, brands, or URLs** — mix search, brand catalog, model pages, and listing URLs
- **Human filters** — price, year range, condition, movement, case material, dial, gender, seller type, country, certified, box & papers
- **Dealer fields** — name, type, rating, reviews, city, country (detail mode)
- **Box & papers booleans** plus `scopeOfDelivery`
- **Numeric shipping** (`shippingAmount`) rather than label-only
- **HTTP-first** — Chrome TLS via `curl_cffi`; residential proxy on Apify

### Input

| Field | Description |
| --- | --- |
| `searchQueries` | Keywords (Rolex Daytona, 126610LN, Nautilus) |
| `brands` | Brand names or slugs (`Rolex`, `patek-philippe`) |
| `startUrls` | Search / brand / model / listing URLs |
| `maxItems` / `maxPages` | Caps |
| `fetchDetails` | `true` = spec sheet + seller (default) |
| `currency` | USD, EUR, GBP, CHF, … |
| Filters | `priceMin` / `priceMax`, `yearFrom` / `yearTo`, `usedOrNew`, `condition`, `movement`, `caseMaterial`, `dialColor`, `gender`, `sellerType`, `countries`, `certified`, `boxAndPapers`, `sortBy` |
| `proxyConfiguration` | Default: Apify Proxy **RESIDENTIAL** |

#### Example — Rolex Daytona cards

```json
{
  "searchQueries": ["Rolex Daytona"],
  "maxItems": 50,
  "fetchDetails": false,
  "currency": "USD",
  "sortBy": "newest"
}
```

#### Example — certified Submariners with box & papers

```json
{
  "brands": ["Rolex"],
  "searchQueries": ["126610LN"],
  "certified": true,
  "boxAndPapers": "box_and_papers",
  "priceMin": 8000,
  "priceMax": 20000,
  "maxItems": 100,
  "fetchDetails": true
}
```

### Output

One dataset row per listing. Card mode is ~15 fields; detail mode adds specs and seller.

| Field | Description |
| --- | --- |
| `listingId` / `url` | Chrono24 id and canonical URL |
| `title` / `brand` / `model` / `referenceNumber` | Identity |
| `priceValue` / `currency` | Numeric asking price |
| `shippingAmount` / `shippingLabel` | Shipping |
| `year` / `condition` / `movement` / `caliber` | Specs (detail) |
| `caseDiameterMm` / `caseMaterial` / `dialColor` | Case / dial |
| `hasBox` / `hasPapers` / `certified` | Delivery & authenticity |
| `sellerName` / `sellerType` / `sellerRating` / `sellerReviewCount` | Dealer |
| `sellerCity` / `sellerCountry` / `countryCode` | Location |
| `images` | Photo URLs |
| `sold` / `reserved` | Listing status when shown |

```json
{
  "listingId": "47341084",
  "url": "https://www.chrono24.com/rolex/submariner-date-116610ln--id47341084.htm",
  "title": "Rolex Submariner Date",
  "brand": "Rolex",
  "referenceNumber": "116610LN",
  "priceValue": 11495,
  "currency": "USD",
  "shippingAmount": 99,
  "hasBox": true,
  "hasPapers": true,
  "sellerName": "Pacific Watch Co.",
  "sellerRating": 4.9,
  "sellerCountry": "United States of America",
  "countryCode": "US"
}
```

### Use cases

- Daily **reference price** pulls for Daytona, Submariner, Nautilus, Royal Oak
- Grey-market **spread** vs boutique / other marketplaces after shipping
- Insurance **replacement value** from full spec sheets
- Dealer **sourcing** — private sellers, certified only, or Chrono24 Direct

### Integration

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('crawloop/chrono24-scraper').call({
  searchQueries: ['Rolex Daytona'],
  maxItems: 25,
  fetchDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token)
run = client.actor("crawloop/chrono24-scraper").call(
    run_input={"searchQueries": ["Rolex Daytona"], "maxItems": 25, "fetchDetails": True}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items[0])
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/crawloop~chrono24-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["Rolex Daytona"],"maxItems":25,"fetchDetails":true}'
```

### MCP and AI assistants

Use this Actor from AI tools via [Apify MCP](https://docs.apify.com/platform/integrations/mcp). Connect your Apify account, then call `crawloop/chrono24-scraper`.

Example prompts:

- "Run Chrono24 Scraper for Rolex Daytona, max 30 listings, and return title, reference, price, and seller country as JSON"
- "Scrape certified Submariner 126610LN listings with box and papers under 18000 USD"
- "After Chrono24 asking prices, pull eBay sold comps with eBay Sold Listings Scraper for the same references"

### Next step

Live Chrono24 asks are one side of the book. For **completed sale comps** on a public marketplace, run [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) on the same reference numbers.

### FAQ

**Do I need start URLs?** No. Keywords and/or brand names are enough. URLs are optional and auto-classified.

**Card mode vs detail mode?** `fetchDetails: false` is faster (search cards only). Enable details for reference, year, movement, seller rating, and box/papers.

**Why residential proxy?** Chrono24 often challenges datacenter IPs. The default input uses Apify Proxy RESIDENTIAL.

**Sold history?** Not in v1. Chrono24 does not expose a public sold-price archive on listing HTML.

### Related Actors

| Actor | Role |
| --- | --- |
| Chrono24 Scraper ◄── you are here | Live luxury watch listings |
| [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | Completed marketplace comps |

# Actor input Schema

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

Free-text Chrono24 searches (brand + model, reference, or keyword). Example: Rolex Daytona, 126610LN, Patek Nautilus. Optional if startUrls or brands is set.

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

Brand names or Chrono24 slugs (Rolex, Omega, patek-philippe). Opens the brand catalog. Combine with filters below.

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

Search, brand, model, or listing URLs. Mixed types are classified automatically. Example: https://www.chrono24.com/rolex/index.htm

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

Hard cap on dataset rows across all queries and URLs.

## `maxPages` (type: `integer`):

Search/brand/model pagination cap. Chrono24 serves up to 60 listings per page.

## `pageSize` (type: `integer`):

Listings per search page (30, 60, or 120).

## `fetchDetails` (type: `boolean`):

Open each listing page for specs (reference, year, movement, box/papers, seller rating). Disable for fast card-only price monitoring.

## `flatten` (type: `boolean`):

Copy nested specs onto CSV-friendly specs\* columns.

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

Display currency for Chrono24 prices.

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

Minimum listing price in the selected currency.

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

Maximum listing price in the selected currency.

## `yearFrom` (type: `integer`):

Earliest production year.

## `yearTo` (type: `integer`):

Latest production year.

## `usedOrNew` (type: `string`):

Restrict to new/unworn or pre-owned watches.

## `condition` (type: `array`):

Seller-stated condition grades.

## `movement` (type: `array`):

Movement type.

## `caseMaterial` (type: `array`):

Case metal or material.

## `dialColor` (type: `array`):

Dial color filter.

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

Men's/unisex or women's watches.

## `sellerType` (type: `string`):

Professional dealer, private seller, or Chrono24 Direct.

## `countries` (type: `array`):

ISO country codes (US, DE, CH, JP). Empty = worldwide.

## `certified` (type: `boolean`):

Only Chrono24 Certified listings (authenticity guarantee).

## `boxAndPapers` (type: `string`):

Filter by original box and/or papers included with the watch.

## `caseDiameterMm` (type: `string`):

Single size (40) or range (36,42).

## `availability` (type: `string`):

Restrict to in-stock listings when needed.

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

How Chrono24 orders results before pagination.

## `searchParams` (type: `object`):

Optional raw Chrono24 query params (overrides the filters above on conflict). Example: {"braceletMaterial": "406", "functions": "1000"}.

## `requestDelaySecs` (type: `number`):

Pause between HTTP requests.

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

Chrono24 blocks many datacenter IPs. Use Apify Proxy RESIDENTIAL on the platform.

## Actor input object example

```json
{
  "searchQueries": [
    "Rolex Daytona"
  ],
  "maxItems": 20,
  "maxPages": 5,
  "pageSize": 60,
  "fetchDetails": true,
  "flatten": true,
  "currency": "USD",
  "usedOrNew": "any",
  "gender": "any",
  "sellerType": "any",
  "certified": false,
  "boxAndPapers": "any",
  "availability": "any",
  "sortBy": "relevance",
  "requestDelaySecs": 0.25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Default dataset items — one Chrono24 listing per row.

# 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 Daytona"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/chrono24-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 Daytona"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/chrono24-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 Daytona"
  ],
  "maxItems": 20
}' |
apify call crawloop/chrono24-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawloop/chrono24-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/4hPZcMrzzSEz020vd/builds/0GXI6KMz5PuT9g9Yc/openapi.json