# Chrono24 Watch Scraper: Prices & Dealer Inventory (`thescrapelab/chrono24-watch-listings-scraper`) Actor

Scrape public Chrono24 watch prices, exact references, condition, box and papers, shipping and dealer inventory. Export clean JSON and CSV snapshots.

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

## Pricing

from $0.95 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Chrono24 Scraper — Watch Prices, References & Dealer Inventory

Build a structured snapshot of public Chrono24 watch listings for market research, competitor price tracking and dealer inventory analysis. Start with a keyword search or a public Chrono24 search, reference, dealer inventory or watch listing URL.

Each result represents one watch listing. Prices are **asking prices**, not confirmed sale prices. Use exact reference numbers to distinguish similar Rolex, Omega, Tudor and other watch models.

### Who it helps

- Watch dealers comparing competitors by exact reference, condition and box/papers.
- Resale businesses checking asking prices and available dealer stock.
- Dataset developers exporting source-linked watch market snapshots.

### Quick start

1. Open the Actor in Apify Console.
2. Enter a search or a Chrono24 URL and set your result limit.
3. Run the Actor and download the dataset as JSON, CSV or Excel.

The default limit is one result for a quick preview. Proxy selection and retries use automatic defaults.

```json
{
  "searchQueries": ["Rolex Submariner 126610LN"],
  "maxItems": 10,
  "referenceNumbers": ["126610LN"]
}
```

For a reference page:

```json
{
  "startUrls": ["https://www.chrono24.com/rolex/ref-126610ln.htm"],
  "maxItems": 100,
  "referenceNumbers": ["126610LN"]
}
```

For several searches, put each phrase in the `searchQueries` list. Search terms and URLs can be combined. Duplicate listing IDs are removed within a run.

### Inputs

| Field | Purpose | Default |
| --- | --- | --- |
| `searchQueries` | Watch keywords or reference searches; up to 100 phrases | Default example searches Rolex Submariner |
| `startUrls` | Public HTTPS Chrono24.com URLs; up to 100 | Empty |
| `maxItems` | Maximum number of delivered listings, from 1 to 10,000 | 1 |
| `referenceNumbers` | Optional exact reference allowlist | No filtering |

Enter at least one search or URL. Reference matching ignores spaces and letter case, but preserves punctuation and suffixes: `126610LN` and `126610LV` are different watches. A result without a reference is excluded when this filter is enabled. Reference numbers filter results; they do not create searches by themselves. Matching uses the seller’s public specifications, which can contain mistakes; the Actor does not authenticate watches.

### Output

The default dataset contains flat JSON records. Unknown optional values are `null`; unavailable details are never invented. Each record includes a stable listing ID, source URL and UTC observation timestamp.

Example from a public listing observed during cloud validation:

```json
{
  "listingId": "48544684",
  "url": "https://www.chrono24.com/rolex/rolex-submariner-date--id48544684.htm",
  "title": "Rolex Submariner Date 116610LN With Box Steel 40mm Black Dial Ceramic 40mm Watch",
  "brand": "Rolex",
  "model": "Submariner Date",
  "referenceNumber": "116610LN",
  "askingPrice": 12499,
  "currency": "USD",
  "shippingPrice": 0,
  "shippingText": "Free, secure shipping within: United States of America",
  "shippingDestination": "United States of America",
  "condition": "Used (Very good)",
  "yearOfProduction": "2020",
  "hasOriginalBox": true,
  "hasOriginalPapers": true,
  "scopeOfDelivery": "Original box, original papers",
  "sellerName": "WATCHBUDDY NYC",
  "sellerType": "dealer",
  "sellerCountry": "United States of America",
  "sellerLocation": "United States of America, New York, NY",
  "availability": "in_stock",
  "scrapedAt": "2026-10-01T22:32:54.067574+00:00"
}
```

Core fields are `listingId`, `url`, `title`, `brand`, `model`, `referenceNumber`, `askingPrice`, `currency`, `condition`, `yearOfProduction`, `scopeOfDelivery`, `hasOriginalBox`, `hasOriginalPapers`, `sellerName`, `sellerType`, `sellerCountry`, `sellerLocation`, `shippingPrice`, `shippingText`, `shippingDestination`, `availability` and `scrapedAt`.

`askingPrice` and `shippingPrice` are numeric amounts in the displayed currency. Shipping can depend on the destination, and taxes or import duties may be additional. Location labels can describe a region rather than a city. Missing box or papers information stays unknown, rather than being interpreted as absent.

A `RUN_SUMMARY` record in the run's key-value store reports delivered output, rejected records, exact-reference exclusions and whether coverage is complete, capped or partial. A capped run reached your requested limit. Partial coverage means an access failure, budget limit, interruption or rejected detail prevented full coverage. Narrow searches before applying exact-reference filtering; very broad filters can stop at a bounded inspection limit with fewer matches.

### Snapshots and availability

Each run is an independent snapshot. You can compare `listingId` and `scrapedAt` across runs to build your own observation history. The Actor does not maintain cross-run tracking state or infer a sale from a disappeared listing. It does not provide transaction prices, confirmed sales or historical first-listed dates.

Availability reflects explicit public-page information where available. `unknown` means the page did not provide a reliable status. Prices and stock can change after collection. Listings without a readable numeric asking price, including price-on-request offers, are excluded. Search relevance is controlled by Chrono24; use the exact reference filter when comparing particular models.

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("thescrapelab/chrono24-watch-listings-scraper").call(
    run_input={
        "searchQueries": ["Rolex Submariner 126610LN"],
        "referenceNumbers": ["126610LN"],
        "maxItems": 100,
    }
)
if run is None:
    raise RuntimeError("Actor did not return a run")
for listing in client.dataset(run.default_dataset_id).iterate_items():
    print(listing)
```

### Pricing and release status

Pay **$0.95 per 1,000 delivered listings**, plus **$0.005 per run** at the Actor's fixed 2 GB memory allocation. Apify bills startup per GB: two $0.0025 startup events total $0.005 at this allocation. Compute, storage and proxy usage are included. One validated, unique listing written to the default dataset is one listing event. Rejected pages and duplicates do not incur listing events. The startup event applies even when no listings are returned.

| Delivered listings | Total event price |
| --- | --- |
| 1 | $0.00595 |
| 10 | $0.01450 |
| 1,000 | $0.95500 |

Set a maximum run charge in Apify Console to control spending. A budget limit can stop collection before `maxItems` is reached. Prices shown in the run's pricing panel are authoritative.

A public-HTML cloud benchmark delivered 1,000 unique listings in approximately 22 minutes. Access conditions and filtering affect speed and yield; this is a measured example, not a throughput guarantee. The Actor currently remains private.

### Limitations and support

Only public Chrono24.com pages are supported. No login, private seller data or transaction interaction is required. The Actor stops on persistent blocking and respects bounded retries for temporary errors. Result counts may be below the requested limit when the search is exhausted, reference filtering excludes results or page access fails.

This is an independent product and is not affiliated with Chrono24. Use the Actor's Issues tab to report a failed run, including the run URL and a small reproducible input.

# Actor input Schema

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

Watch names, brands or references. Leave empty when using URLs.

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

Paste public chrono24.com search, brand, reference, dealer inventory or watch listing URLs.

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

Total unique listings across all searches and URLs.

## `referenceNumbers` (type: `array`):

Verify references from listing details. Suffixes are significant; spaces and capitalization are ignored.

## Actor input object example

```json
{
  "searchQueries": [
    "Rolex Submariner"
  ],
  "startUrls": [],
  "maxItems": 1,
  "referenceNumbers": []
}
```

# Actor output Schema

## `listings` (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"
    ],
    "maxItems": 1
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thescrapelab/chrono24-watch-listings-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/k9PxRkUjyAasSa5Hb/builds/pOP8t0rXKvbpuhEQj/openapi.json