# Chrono24 Watch Market Analyzer — Price Distribution & Comps (`jdepablos/chrono24-watch-analyzer`) Actor

One call = one watch model analyzed. Live market analysis from Chrono24 listings: median asking price, percentiles, market depth, seller mix + cleaned comps. Built for AI agents, dealers and collectors.

- **URL**: https://apify.com/jdepablos/chrono24-watch-analyzer.md
- **Developed by:** [Juan de Pablos](https://apify.com/jdepablos) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 1 total users, 1 monthly users, 97.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 watch analyses

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Market Analyzer — Price Distribution & Comps

**One call = one watch model analyzed.** Get the live market picture of any watch from Chrono24 — the world's largest luxury watch marketplace — as structured data: median asking price, percentiles, market depth, seller-country mix, Certified share, and the cleaned comparable listings behind every number. Built for AI agents, dealers, collectors and resale platforms.

Not another raw-listings scraper: listings are **cleaned before the math** (promoted cards, straps/bezels/dials sold alone, parts/defective/replica listings and duplicates are filtered out), so the stats describe the actual model you asked about.

### What you get

```json
{
    "query": "Rolex Submariner 16610",
    "domain": "chrono24.es",
    "analysis": {
        "n": 46,
        "currency": "EUR",
        "median": 9150,
        "meanTrimmed": 9877.3,
        "p10": 8000, "p25": 8690, "p75": 11400, "p90": 13465,
        "min": 7000, "max": 17012,
        "medianExclShipping": 9150,
        "priceBasis": "asking",
        "marketDepth": 1181,
        "certifiedSharePct": 21.7,
        "dealerCountryMix": [
            { "country": "IT", "count": 10 },
            { "country": "ES", "count": 7 },
            { "country": "DE", "count": 7 }
        ],
        "confidence": "high"
    },
    "comps": [
        {
            "title": "Rolex Submariner Date",
            "subtitle": "16610 (2007) with Rolex warranty (03-2027)",
            "price": 8000,
            "currency": "EUR",
            "sellerCountry": "NL",
            "certified": "optional",
            "chrono24Direct": false,
            "url": "https://www.chrono24.es/rolex/...--id12345678.htm"
        }
    ],
    "meta": {
        "rawParsed": 60,
        "compsAnalyzed": 46,
        "filteredOut": { "promoted": 13, "junkTitle": 1, "accessory": 0 },
        "marketDepth": 1181,
        "fetchedAt": "2026-07-05T01:00:00.000Z"
    }
}
```

### Why asking prices matter (and what they are not)

`priceBasis` is always `"asking"`: these are live dealer and private asks, **not confirmed sales**. Asking-price distribution tells you where the market is priced *today* — what you'd pay right now, how deep the supply is (`marketDepth`), and how spread the market is (`p10`–`p90`). To negotiate or estimate liquidation value, combine it with confirmed-sales data (e.g. our [eBay Sold Price Appraiser](https://apify.com/jdepablos/ebay-sold-price-appraiser) on the same model) and you get both sides of the market: ask vs sold.

### Input

| Field | Default | Notes |
|---|---|---|
| `query` | — | Brand + model (+ reference): `"Rolex Submariner 16610"` |
| `items` | — | Batch of up to 25 queries, each may override any option |
| `domain` | `chrono24.com` | `.com` USD · `.es`/`.de`/`.fr`/`.it` EUR · `.co.uk` GBP |
| `priceMin` / `priceMax` | — | Trim outliers before stats |
| `maxComps` | 60 | Comps returned (stats always use all cleaned listings) |
| `strictClean` | `true` | Filter promoted/accessory/parts/replica/duplicate listings |
| `minTitleMatch` | `"0.6"` | Share of query tokens required in the listing title. Set `"1"` to require the exact reference |
| `sellerCountries` | — | ISO-2 filter, e.g. `["ES", "DE"]` |

**Tip:** include the reference number in `query` and set `minTitleMatch: "1"` when you need reference-exact stats (e.g. `16610` vs `16610LV` price different markets).

### Use with AI agents (MCP)

Give your agent a real-time watch-market tool via Apify's MCP server:

```
https://mcp.apify.com?tools=jdepablos/chrono24-watch-analyzer
```

The output schema is designed for agents: one call returns a complete, self-describing market analysis — no pagination, no post-processing.

### Pricing

Pay per event: **$0.02 per watch analysis** (up to 60 cleaned comps included). Analyses that return no data are **never charged** — you only pay when you get numbers.

### FAQ

**Which Chrono24 domains are supported?** `chrono24.com`, `.es`, `.de`, `.fr`, `.it`, `.co.uk`. The domain sets the listing currency; inventory is largely global.

**How many listings feed each analysis?** Up to 60 (one result page, relevance-sorted) after cleaning. `marketDepth` reports the total supply matching your query.

**Why were some listings filtered out?** Check `meta.filteredOut`: promoted cards, accessory listings (a strap "for Submariner" is not a Submariner), parts/defective/replica titles, duplicates and price-on-request listings never enter the stats.

**Can I track a model over time?** Yes — schedule a daily/weekly run and diff `median`/`marketDepth`. The analysis is deterministic per snapshot.

**Is this affiliated with Chrono24?** No. Data comes from publicly visible listings.

# Actor input Schema

## `query` (type: `string`):

Brand + model (+ reference) of the watch, e.g. "Rolex Submariner 16610" or "Omega Speedmaster Professional". For batches use `items` instead.

## `items` (type: `array`):

Analyze up to 25 watches in one run: `[{"query": "Rolex Submariner 16610"}, {"query": "Tudor Black Bay 58", "domain": "chrono24.es"}]`. Each item may override any top-level option.

## `domain` (type: `string`):

Marketplace domain — determines listing currency (chrono24.com → USD, .es/.de/.fr/.it → EUR, .co.uk → GBP).

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

Ignore listings below this price (in the domain currency). Applied after parsing.

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

Ignore listings above this price (in the domain currency). Applied after parsing.

## `maxComps` (type: `integer`):

How many cleaned comparable listings to include in the output (stats always use all of them).

## `includeComps` (type: `boolean`):

Return the comparable listings alongside the analysis.

## `strictClean` (type: `boolean`):

Filter promoted cards, accessories (straps, bezels, dials sold alone), parts/defective/replica listings and duplicates before computing stats. Recommended.

## `minTitleMatch` (type: `string`):

Minimum share of query tokens that must appear in the listing title for it to count as the same model. Decimal as string, e.g. "0.6".

## `sellerCountries` (type: `array`):

Optional ISO-2 country codes — keep only listings from these seller countries, e.g. \["ES", "DE"].

## `allowDomainFallback` (type: `boolean`):

Chrono24 domains all serve the same global inventory (only language and currency differ). If the requested domain is temporarily blocking automated access, retry the analysis on up to 2 alternative domains. The output marks the substitution via `requestedDomain` — note the currency may differ from the requested domain.

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

Chrono24 rate-limits by IP — residential proxy recommended (default).

## `monitorMode` (type: `boolean`):

For scheduled smoke tests: when the source blocks every attempt (anti-bot weather, not a code fault), the run exits SUCCEEDED with a clear status message instead of FAILED, and notifies `monitorEmail`. Code faults (unrecognized markup) still fail the run.

## `monitorEmail` (type: `string`):

Email to notify (via apify/send-mail) when monitor mode detects a fully blocked source. On Apify free plans this must be the account owner's email.

## Actor input object example

```json
{
  "query": "Rolex Submariner 16610",
  "domain": "chrono24.com",
  "maxComps": 60,
  "includeComps": true,
  "strictClean": true,
  "minTitleMatch": "0.6",
  "allowDomainFallback": true,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "monitorMode": false
}
```

# 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 = {
    "query": "Rolex Submariner 16610",
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jdepablos/chrono24-watch-analyzer").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 = {
    "query": "Rolex Submariner 16610",
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("jdepablos/chrono24-watch-analyzer").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 '{
  "query": "Rolex Submariner 16610",
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call jdepablos/chrono24-watch-analyzer --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/tH3MlLcabIkucySsm/builds/CeJCu58XcZufRwBwF/openapi.json