# Chrono24 $1💰 Luxury Watches, Prices, Specs & Reviews (`abotapi/chrono24-scraper`) Actor

From $1/1K. Extract luxury watch listings from Chrono24, the global marketplace for new and pre-owned watches. Search by keyword, filters, or URLs. Returns 50+ fields including brand, model, reference number, price, year, condition, movement, case specs, seller, location, and images.

- **URL**: https://apify.com/abotapi/chrono24-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 4 total users, 2 monthly users, 92.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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.
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 Watch Scraper

Extract structured luxury watch listings from Chrono24, the global marketplace for new and pre-owned watches. Search by keyword and filters, or paste any mix of detail, brand, model, and search URLs. Each listing comes back as clean JSON with 50+ fields: brand, model, reference number, price, year, condition, the full movement and case spec sheet, seller and location, and every image. Ideal for dealers, collectors, analysts, and anyone tracking the watch market.

### Why this scraper

- 50+ fields per watch: full spec sheet plus seller, certification, listing code, base caliber, dial numerals, and the buying-agent block.
- Seller rating and recent buyer reviews (date, stars, watch, reviewer, text) attached to every listing, at no extra cost.
- Two modes: keyword + filter search, or direct URLs (detail, brand, model, or search pages mixed freely).
- Card mode for fast, cheap harvesting (lightweight fields straight from the results page) or full-detail mode for the complete spec sheet.
- Rich filters: price, year, condition, case material, dial color, bracelet material, seller type, country, reference number, and more, with six sort orders.
- Browse Chrono24's own curated "Top Deals" collection with one toggle, or fetch it directly as a URL, complete with the site's own per-listing savings percentage (card mode).
- Runs on every Apify plan including Free; residential proxy is optional for the widest IP rotation on large runs.
- Automatic pagination, de-duplication, per-record output, and optional flattening to specs\_\* columns for CSV.

### Data you get

> Sample shape, values are illustrative placeholders, not from a live listing.

| Field | Example |
|---|---|
| listingId | 00000001 |
| title | Rolex Submariner Date |
| brand | Rolex |
| model | Submariner Date |
| referenceNumber | 126610LN |
| price | 12500 |
| currency | USD |
| year | 2022 |
| condition | Used (Very good) |
| sellerCountry | DE |
| sellerType | Dealer |
| sellerUsername | sample\_dealer |
| certificationStatus | Basic |
| specs\_movement | Automatic |
| specs\_caliber | 3235 |
| specs\_caseMaterial | Steel |
| specs\_caseDiameter | 41 mm |
| specs\_waterResistance | 30 ATM |
| specs\_dialColor | Black |
| specs\_braceletMaterial | Steel |
| specs\_functions | Date |
| sellerRating | 4.8 |
| reviewCount | 12 |
| reviews | \[{"date":"2026-01-01","rating":5,"watch":"Rolex Submariner","reviewerName":"Jane D.","reviewerCountry":"United States of America","text":"Sample review text."}] |
| images | \["https://img.chrono24.com/images/uhren/00000001-Square480.jpg"] |
| listingUrl | https://www.chrono24.com/rolex/submariner--id00000001.htm |

### How to use

Search by keyword with filters:

```json
{
  "mode": "search",
  "searchQuery": "Rolex Submariner",
  "searchParams": { "priceFrom": 8000, "priceTo": 15000, "usedOrNew": "used", "caseMaterials": "steel" },
  "sortBy": "price-asc",
  "fetchDetails": true,
  "maxListings": 50
}
```

Fast card harvesting (no per-listing fetch):

```json
{
  "mode": "search",
  "searchQuery": "Omega Speedmaster",
  "fetchDetails": false,
  "maxListings": 200
}
```

Chrono24's curated Top Deals collection, with the site's own savings percentage per listing (card mode, needed to see `discountPercent` -- see "Deals & pricing" below):

```json
{
  "mode": "search",
  "dealsOnly": true,
  "sortBy": "savings-desc",
  "fetchDetails": false,
  "maxListings": 50
}
```

Direct URLs (detail + model + search mixed):

```json
{
  "mode": "url",
  "urls": [
    "https://www.chrono24.com/rolex/submariner--mod4.htm",
    "https://www.chrono24.com/patek-philippe/nautilus--id00000001.htm",
    "https://www.chrono24.com/search/index.htm?query=Daytona&dosearch=true"
  ],
  "fetchDetails": true,
  "maxListings": 100
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| mode | string | search | "search" (keyword + filters) or "url" (paste links). |
| searchQuery | string | - | Keyword for search mode. Empty browses everything matching the filters. |
| searchParams | object | {} | Filters: priceFrom, priceTo (USD), year, usedOrNew, caseMaterials, dialColor, braceletMaterial, sellerType, countryIds, referenceNumber, caseDiameter, man, certified, inStock. Friendly words or raw Chrono24 ids. |
| sortBy | string | relevance | relevance, price-asc, price-desc, newest, popularity, savings-desc (Top Deals collection only; falls back to relevance elsewhere). |
| dealsOnly | boolean | false | Browse Chrono24's curated Top Deals collection instead of a regular search. Ignores searchQuery and searchParams (not supported by that page); sortBy still applies, including savings-desc. Card mode (fetchDetails off) also picks up each listing's rendered savings badge as discountPercent -- see "Deals & pricing". |
| urls | array | - | Detail, brand, model, or search URLs (URL mode). The Top Deals collection also works here as a plain URL: `https://www.chrono24.com/watches/top-deals.htm`. |
| fetchDetails | boolean | true | On: full spec sheet per listing. Off: lightweight cards from the results page. |
| fetchSellerReviews | boolean | true | Attach seller rating + recent buyer reviews to each listing. Read in the same pass as the details, so no extra cost. Only applies when fetchDetails is on. |
| flatten | boolean | true | Also expose nested specs as flat specs\_\* columns. |
| includeRaw | boolean | false | Attach a rawHtmlBytes diagnostic field. |
| maxListings | integer | 20 | The single cap on output. 0 means unlimited. |
| maxPages | integer | 0 | Safety bound on pages per search URL (120 listings per page). 0 means unlimited: the run stops at Max listings, or when a page stops returning new listings. |
| proxy | object | Apify Proxy | Works on every plan. Residential gives the widest rotation. |

### Output example

> Sample shape, values are illustrative placeholders, not from a live listing.

```json
{
  "rowType": "detail",
  "listingId": "00000001",
  "watchId": "00000001",
  "listingUrl": "https://www.chrono24.com/rolex/submariner--id00000001.htm",
  "title": "Rolex Submariner Date",
  "brand": "Rolex",
  "model": "Submariner Date",
  "referenceNumber": "126610LN",
  "listingCode": "AAA000",
  "price": 12500,
  "currency": "USD",
  "availability": "InStock",
  "condition": "Used (Very good)",
  "year": "2022",
  "location": "Germany, Bavaria, Munich",
  "sellerCountry": "DE",
  "sellerUsername": "sample_dealer",
  "merchantCountry": "Germany",
  "certificationStatus": "Basic",
  "isDeal": false,
  "scopeOfDelivery": "Original box, original papers",
  "gender": "Men's watch/Unisex",
  "buyingAgent": { "fullName": "Client Advisor", "office": "Sample Office", "region": "Europe" },
  "specs": {
    "movement": "Automatic",
    "caliber": "3235",
    "baseCaliber": "3235",
    "powerReserve": "70 h",
    "jewels": "31",
    "caseMaterial": "Steel",
    "caseDiameter": "41 mm",
    "waterResistance": "30 ATM",
    "bezelMaterial": "Ceramic",
    "crystal": "Sapphire crystal",
    "dialColor": "Black",
    "braceletMaterial": "Steel",
    "clasp": "Fold clasp",
    "functions": "Date"
  },
  "sellerRating": 4.8,
  "reviewCount": 12,
  "reviews": [
    {
      "date": "2026-01-01",
      "rating": 5,
      "watch": "Rolex Submariner",
      "received": "2026-01-01",
      "shippedFrom": "United States of America",
      "reviewerName": "Jane D.",
      "reviewerCountry": "United States of America",
      "text": "Sample review text appears here."
    }
  ],
  "images": ["https://img.chrono24.com/images/uhren/00000001-Square480.jpg"],
  "scrapedAt": "2026-01-01T00:00:00.000Z"
}
```

Card mode output (`fetchDetails: false`) on the Top Deals collection, showing `discountPercent`:

```json
{
  "rowType": "card",
  "listingId": "00000002",
  "watchId": "00000002",
  "listingUrl": "https://www.chrono24.com/tag-heuer/formula-1--id00000002.htm",
  "title": "TAG Heuer Formula 1 Gulf Edition",
  "price": 973,
  "currency": "USD",
  "discountPercent": 25,
  "sellerType": "Private Seller",
  "countryCode": "UK",
  "thumbnail": "https://img.chrono24.com/images/uhren/00000002-Square480.jpg",
  "images": ["https://img.chrono24.com/images/uhren/00000002-Square480.jpg"],
  "scrapedAt": "2026-01-01T00:00:00.000Z"
}
```

### Deals & pricing

Chrono24 is a peer-to-peer / dealer marketplace: each seller sets one asking price for their own watch, and the site does not publish a structured was-price, original-price, or MSRP field next to any listing, curated collection included, so this scraper does not fabricate one.

It does publish one real savings figure, though: on the curated Top Deals collection (`dealsOnly: true`, or the Top Deals URL), every listing card carries a rendered "-N%" badge that is the site's own savings metric (it's what the page's own "Savings, highest first" sort order ranks by). Card mode (`fetchDetails: false`) picks this up as `discountPercent`, an integer percentage, straight off the results page at no extra fetch. The badge only exists on the results-page card; the full detail page (`fetchDetails: true`) carries just the boolean `isDeal` flag with no percentage attached, so use `discountPercent` in card mode when you need the number, and `isDeal` in detail mode as a lighter deal/no-deal signal.

### Send results into your apps (MCP connectors)

Optionally pipe results into the apps you already use through Model Context Protocol (MCP) connectors. Authorize a connector once under Apify, Settings, Integrations, then select it in the input. Notion receives a page per item; other connectors get a best-effort write or digest. The connector receives a condensed, human-readable summary per item (a title plus key fields), not the full JSON; the complete record always stays in the Apify dataset. Leave the field empty to skip. Supported: Notion, Linear, Airtable, Apify.

### Plan requirement

This actor runs on Apify Proxy, available on every plan including Free. For the widest IP rotation on large runs, set Proxy to Residential (included on Starter and above). If no Apify Proxy is available, the actor falls back to a backup connection that may be slower or return fewer results.

### Verification note (2026-08-31)

URL and search modes re-verified against the live site on 2026-08-31 using the actor's own clearance-plus-fetch harness: a filter-only search (priceTo=5000) returned 120 listings on page 1, adding query Daytona narrowed it to 60 and adding the price ceiling to the Daytona query to 2 listings, and pasted detail, brand, and model URLs all resolved into real data (a detail URL returned 41 populated fields for a Rolex at $19,999, the Rolex brand page returned 60 listings). No defect found; version bumped so the Store listing carries a freshly dated, re-verified build.

# Actor input Schema

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

How to find watches: build a search from a keyword + filters, or paste your own URLs.

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

Keyword to search, e.g. 'Submariner', 'Omega Speedmaster', 'Patek Nautilus'. Leave empty to browse everything matching the filters below.

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

Filter the search. Accepts friendly words or raw Chrono24 ids. Keys: priceFrom, priceTo (USD), year, usedOrNew ('new' | 'used'), caseMaterials (steel | yellow gold | rose gold | white gold | platinum | titanium | ceramic), dialColor (black | blue | green | white | silver | grey | meteorite), braceletMaterial (steel | leather | rubber | yellow gold), sellerType ('chrono24 direct' | 'professional dealer' | 'private sellers'), countryIds (ISO code, e.g. DE), referenceNumber, caseDiameter (mm), man (brand slug, e.g. rolex), certified (true), inStock (true).

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

Result order (search mode). 'Savings' only has an effect when Top Deals collection only is on; elsewhere it falls back to Relevance.

## `dealsOnly` (type: `boolean`):

Browse Chrono24's own curated 'Top Deals' collection instead of a regular search. When on, Search keyword and Filters are ignored (that combination is not supported by Chrono24's Top Deals page); only Sort by still applies (including the 'Savings, highest first' order, only available here). Chrono24 does not publish a structured was-price/original-price/MSRP field on any listing, but the Top Deals collection does show a rendered '-N%' savings badge per listing, which card mode (Fetch full details off) extracts as discountPercent. That badge is not present on the full detail page; use isDeal there as the deal signal instead.

## `urls` (type: `array`):

Any mix of Chrono24 detail (--id), brand (/rolex/index.htm), model (--mod) or search URLs. Detail URLs return one watch each; brand / model / search URLs paginate automatically.

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

On (default): fetch each listing's detail page for the full 50+ field spec sheet. Off: emit lightweight cards straight from the results page (faster, fewer fields, no per-listing fetch).

## `fetchSellerReviews` (type: `boolean`):

Attach the seller's rating and recent buyer reviews (date, stars, watch, reviewer, text) to each listing. Read from the listing page in the same pass, so it adds no extra cost. Only applies when Fetch full details is on.

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

Also expose nested specs as flat specs\_\* columns for easy CSV / spreadsheet export.

## `includeRaw` (type: `boolean`):

Attach a rawHtmlBytes field per record (diagnostics). Does not change other fields.

## `maxListings` (type: `integer`):

The one cap on output. Stops the run once this many listings are collected. Set 0 for unlimited.

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

Safety bound on pages walked per search / brand / model URL (120 listings per page). Set 0 for unlimited: the run then stops at Max listings, or when a page stops returning new listings, whichever comes first.

## `proxy` (type: `object`):

Works on every Apify plan including Free. Residential gives the widest IP rotation. Free plans fall back to a backup connection.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON; the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "Rolex Submariner",
  "searchParams": {},
  "sortBy": "relevance",
  "dealsOnly": false,
  "urls": [
    "https://www.chrono24.com/rolex/submariner--mod4.htm"
  ],
  "fetchDetails": true,
  "fetchSellerReviews": true,
  "flatten": true,
  "includeRaw": false,
  "maxListings": 20,
  "maxPages": 0,
  "proxy": {
    "useApifyProxy": true
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "search",
    "searchQuery": "Rolex Submariner",
    "searchParams": {},
    "urls": [
        "https://www.chrono24.com/rolex/submariner--mod4.htm"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/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 = {
    "mode": "search",
    "searchQuery": "Rolex Submariner",
    "searchParams": {},
    "urls": ["https://www.chrono24.com/rolex/submariner--mod4.htm"],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/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 '{
  "mode": "search",
  "searchQuery": "Rolex Submariner",
  "searchParams": {},
  "urls": [
    "https://www.chrono24.com/rolex/submariner--mod4.htm"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/chrono24-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/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/88UsGupgzhUUkeDle/builds/4iYMIoiYf9ogvozbb/openapi.json