# Chrono24 Watch Scraper (`masked_hacker/chrono24-scraper`) Actor

Scrape watch listings (brand, model, ref, price, condition, seller) from Chrono24.

- **URL**: https://apify.com/masked\_hacker/chrono24-scraper.md
- **Developed by:** [Masked Hacker](https://apify.com/masked_hacker) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 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/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

## Chrono24 Watch Scraper: Prices, Specs & Seller Data

Turn any [Chrono24](https://www.chrono24.com) search into a clean, structured dataset of luxury
watch listings. Search by brand or keyword and get **full detail-page data** for every watch:
price, reference number, movement, case and bracelet material, year, condition, box & papers,
plus the seller's name, rating and location.

Perfect for **price research, market comps, dealer monitoring, and resale analytics** across
Rolex, Omega, Patek Philippe, Audemars Piguet and every other brand on the marketplace.

### What you get

- 🔎 **Search by brand or keyword**, or paste your own Chrono24 search URLs.
- 🧾 **Full spec sheet per watch:** reference, movement, case, bracelet, diameter, water
  resistance, year, condition and scope of delivery.
- 💶 **Normalized price + currency** so you can compare listings directly.
- 🏪 **Seller intelligence:** dealer name, rating and location.
- 🖼️ **All listing images**, deduplicated.
- 📄 Clean JSON / CSV / Excel export, ready for a spreadsheet or a pipeline.

### Pricing

**Pay per event:** **$0.015 per watch listing** returned, plus a small per-run start fee. You
only pay for watches you actually receive; no monthly subscription.

### Input

| Field | Type | Description |
|---|---|---|
| `searchQueries` | string\[] | Brands or keywords to search, e.g. `rolex submariner`. |
| `startUrls` | url\[] | Chrono24 search URLs to scrape directly, instead of or alongside queries. |
| `maxItems` | int | Stop after this many watch listings (default 200). |
| `proxyConfiguration` | proxy | Residential proxy recommended. Chrono24 blocks datacenter IPs. |

#### Example input

```json
{
  "searchQueries": ["rolex submariner", "omega speedmaster"],
  "maxItems": 100
}
```

### Output

One record per watch listing. Search-card data is merged with the watch's detail page; if a
detail page can't be fetched, the row is still returned with the card fields and
`detailFetched: false`.

| Field | Description |
|---|---|
| `brand`, `model`, `referenceNumber` | Watch identity. |
| `price`, `currency` | Asking price and currency. |
| `condition`, `yearOfProduction` | Condition and production year. |
| `movement`, `caseMaterial`, `braceletMaterial`, `caseDiameter`, `waterResistance` | Core specs. |
| `scopeOfDelivery` | Box & papers. |
| `dealerName`, `dealerRating`, `location` | Seller details. |
| `images`, `imageUrl` | Listing photos. |
| `description`, `fullDescription`, `specs` | Search-card summary, full detail text, and the raw spec table. |
| `badge` | Listing badge (e.g. certification / top-listing marker), when present. |
| `detailFetched` | `true` when the detail page was merged, `false` if only card fields are present. |
| `url`, `id`, `query`, `scrapedAt` | Listing URL, ID, source query and scrape time. |

#### Example output

```json
{
  "brand": "Rolex",
  "model": "Submariner Date",
  "referenceNumber": "126610LN",
  "price": 14500,
  "currency": "USD",
  "condition": "Very good",
  "yearOfProduction": "2022",
  "movement": "Automatic",
  "caseMaterial": "Steel",
  "dealerName": "Prestige Time",
  "dealerRating": 4.9,
  "location": "United States of America, New York",
  "url": "https://www.chrono24.com/rolex/submariner--id26529871.htm",
  "detailFetched": true
}
```

### FAQ

**Do I need a Chrono24 account or API key?** No. Just provide a search query or URL.

**Which currencies are returned?** The price and currency shown on each listing, inferred from
the price symbol on the page.

**Is this legal?** The actor collects only publicly available listing data. You are responsible
for complying with Chrono24's terms and applicable law in your use of the data.

# Actor input Schema

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

Watch searches, e.g. brand/model names.

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

Direct Chrono24 search/model result URLs to scrape instead of (or with) queries.

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

Stop after this many listings (across all queries).

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

Residential required — Chrono24 blocks datacenter IPs.

## Actor input object example

```json
{
  "searchQueries": [
    "patek philippe nautilus"
  ],
  "maxItems": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped watch listings in the default dataset.

# 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",
        "omega speedmaster"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("masked_hacker/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 submariner",
        "omega speedmaster",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("masked_hacker/chrono24-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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",
    "omega speedmaster"
  ]
}' |
apify call masked_hacker/chrono24-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=masked_hacker/chrono24-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/YWBCZi6aw7X8kmtxP/builds/SebekwuHbahUpqTsI/openapi.json