# Chrono24 Scraper — Luxury Watch Prices & Listings (`studio-amba/chrono24-scraper`) Actor

Scrape luxury watch listings from Chrono24.com, the world's largest pre-owned watch marketplace. Extract prices, reference numbers, condition, year, material, movement, and seller info for any brand or model. No login needed.

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

## Pricing

from $20.00 / 1,000 result scrapeds

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/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

Scrape luxury watch listings from Chrono24.com — the world's largest online marketplace for pre-owned and new watches.

### Why use this actor?

Chrono24 lists hundreds of thousands of watches from dealers and private sellers worldwide, but the site sits behind a Cloudflare challenge, so it's not accessible with a plain HTTP request or a naive scraper. This actor gets you the data anyway: price, reference number, condition, year, material, and seller info for any brand, model, or reference you search for. Useful for price-tracking a specific reference across sellers, building a comps database for valuation, monitoring new listings for a model you collect, or feeding a watch price-history tool.

### How to scrape Chrono24 data

Give the actor a search query — a brand ("Rolex"), a model ("Omega Speedmaster"), or a reference number ("Rolex 16610") — and it does the rest:

1. Fetches the Chrono24 search results page for your query (up to 60 listings per page) through Bright Data Web Unlocker, which handles the Cloudflare challenge.
2. Collects listing URLs and paginates until it has enough candidates for `maxResults`.
3. Visits each listing's detail page and pulls the structured product data Chrono24 embeds in the page (brand, model, reference number, year, material, movement, condition) plus the seller's name, type, and country.
4. Pushes one row per listing to the dataset.

Run it directly from the Apify Console, via the API, or with any of the official SDKs (JavaScript, Python). Typical workflows:

- **Reference lookup**: search a specific reference number to see every current listing and price for that exact watch
- **Brand sweep**: search a brand name and set a high `maxResults` to pull a broad price sample
- **Scheduled monitoring**: run daily on a saved search to catch new listings or price drops
- **Comps / valuation feed**: export JSON or CSV and join on `referenceNumber` to build a price-history dataset

No login or account needed on Chrono24 — this scrapes public listing pages only.

### Input

| Field | Type | Required | Description |
|-------|------|----------|--------------|
| `searchQuery` | String | No | Brand, model, or reference number to search for. Defaults to `"Rolex"` when left empty. |
| `maxResults` | Integer | No | Maximum listings to return. Default `30`, hard-capped at `300`. |
| `fetchDetails` | Boolean | No | When `true` (default), fetches each listing's detail page for reference number, year, condition, material, movement, and seller info — one extra request per result. When `false`, only search-page fields are returned (title, brand guess, price, currency, image, url) — faster and cheaper. |
| `requestDelaySecs` | Integer | No | Pause between Bright Data requests. Default `1`. Raise this if you see retry warnings in the log. |
| `brightDataApiKey` | String | No | Bright Data Web Unlocker API key. Pre-configured on this actor — you normally don't need to set it. |
| `proxyConfiguration` | Object | No | Accepted for compatibility. Unblocking is handled by Bright Data, not Apify proxy. |

### Output

Each result contains:

| Field | Type | Example |
|-------|------|---------|
| `listingId` | String | `"48333548"` |
| `listingTitle` | String | `"Rolex Submariner No Date Black PVD Coating..."` |
| `brand` | String | `"Rolex"` |
| `model` | String | `"Submariner (No Date)"` |
| `referenceNumber` | String | `"14060"` |
| `year` | Number | `2001` |
| `yearRaw` | String | `"2001"` |
| `condition` | String | `"Used (Very good)"` |
| `conditionState` | String | `"used"` |
| `material` | String | `"Steel"` |
| `caseDiameter` | String | `"40 mm"` |
| `movement` | String | `"Automatic"` |
| `price` | Number | `8000` |
| `currency` | String | `"USD"` |
| `sellerName` | String | `"BRICKELL WATCHES"` |
| `sellerType` | String | `"dealer"` |
| `sellerCountry` | String | `"US"` |
| `imageUrl` | String | Primary listing image |
| `imageUrls` | Array | All listing images |
| `url` | String | Listing detail page URL |
| `scrapedAt` | String | ISO 8601 timestamp |
| `searchQuery` | String | Input echo |

`currency` is reported exactly as published — Chrono24 is a global marketplace and most listings price in USD regardless of seller country, so don't assume EUR.

### Example output

```json
{
    "listingId": "48333548",
    "listingTitle": "Rolex Submariner No Date Black PVD Coating Black dial Stainless Steel Watch Only 14060 Good Automatic",
    "brand": "Rolex",
    "model": "Submariner (No Date)",
    "referenceNumber": "14060",
    "year": 2001,
    "yearRaw": "2001",
    "condition": "Used (Good)",
    "conditionState": "used",
    "material": null,
    "caseDiameter": "40 mm",
    "movement": "Automatic",
    "price": 8000,
    "currency": "USD",
    "sellerName": "BRICKELL WATCHES",
    "sellerType": "dealer",
    "sellerCountry": "US",
    "imageUrl": "https://img.chrono24.com/images/uhren/48333548-es2kuz2kstkojjj7qlk8j2hz-ExtraLarge.jpg",
    "imageUrls": [
        "https://img.chrono24.com/images/uhren/48333548-es2kuz2kstkojjj7qlk8j2hz-ExtraLarge.jpg",
        "https://img.chrono24.com/images/uhren/48333548-tcr05agt472d6nqdd0ze5szu-ExtraLarge.jpg"
    ],
    "url": "https://www.chrono24.com/rolex/submariner-no-date-black-pvd-coating-black-dial-stainless-steel-watch-only-14060-good-automatic--id48333548.htm",
    "scrapedAt": "2026-09-04T09:14:18.611Z",
    "searchQuery": "Rolex Submariner"
}
```

### Cost estimate

With `fetchDetails` on (default), each result costs one search-page fetch share plus one detail-page fetch — two Bright Data Web Unlocker requests per result at roughly 60 results per search-page fetch. Budget for roughly 1 Bright Data request per result at scale. A 30-result run typically finishes in under a minute with the default 1-second request delay.

### Limitations / known issues

- Chrono24 is protected by Cloudflare and reached exclusively through Bright Data Web Unlocker — a direct HTTP request to the site returns a 403 challenge page.
- `material` and `condition` are pulled from the listing's specs table; a small share of listings (roughly 1 in 10 in testing) render a slightly different template and omit one or two of these fields — `conditionState` (machine-normalized from the listing's own schema.org data) is the more reliable field to filter/sort on.
- Search results cap at 60 listings per page; the actor paginates automatically up to `maxResults`.
- `sellerCountry` is a 2-letter country code only — Chrono24 does not publish the seller's city or full address on the listing page.
- Pricing and availability reflect the moment the actor ran; watch prices on Chrono24 change frequently and listings can be sold or removed.
- A run's usage cost only settles once the run finishes with status `SUCCEEDED` — check the run's final status before relying on the billed amount.

### Related Scrapers

- [Back Market Scraper](https://apify.com/studio-amba/back-market-scraper) — refurbished electronics marketplace
- [Vinted Scraper](https://apify.com/studio-amba/vinted-scraper) — second-hand fashion marketplace
- [Autoscout24 Scraper](https://apify.com/studio-amba/autoscout24-scraper) — used car marketplace
- [Immoweb Scraper](https://apify.com/studio-amba/immoweb-scraper) — real estate listings
- [Bazaraki Scraper](https://apify.com/studio-amba/bazaraki-scraper) — general classifieds marketplace

# Actor input Schema

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

Search Chrono24 by brand, model, or reference number (e.g. 'Rolex Submariner', 'Omega Speedmaster', 'Patek Philippe 5711'). Defaults to 'Rolex' when left empty.

## `maxResults` (type: `integer`):

Maximum number of watch listings to return. Hard-capped at 300 per run (one search page holds up to 60 listings; with detail enrichment on, each result costs one extra request).

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

When on (default), fetches each listing's detail page for reference number, year, condition, material, movement, and seller info — one extra request per result. When off, only the fields available on the search results page are returned (title, brand guess, price, currency, image, url) — faster and cheaper, but incomplete.

## `requestDelaySecs` (type: `integer`):

Pause between Bright Data requests to avoid tripping Chrono24's/Bright Data's rate limiting. Raise this if you see repeated retry warnings in the log.

## `brightDataApiKey` (type: `string`):

Bright Data Web Unlocker API key. Required to reach Chrono24 behind its Cloudflare challenge. Can also be set as the BRIGHT\_DATA\_API\_KEY environment variable (pre-configured for this actor).

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

Proxy settings. Optional — unblocking is handled by Bright Data Web Unlocker, not this proxy.

## Actor input object example

```json
{
  "searchQuery": "Rolex Submariner",
  "maxResults": 20,
  "fetchDetails": true,
  "requestDelaySecs": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchQuery": "Rolex Submariner",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/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 = {
    "searchQuery": "Rolex Submariner",
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/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 '{
  "searchQuery": "Rolex Submariner",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/chrono24-scraper --silent --output-dataset

```

## MCP server setup

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