# Chrono24 Scraper with Description & Features (`fatihtahta/chrono24-scraper`) Actor

Extract unlimited Chrono24 watch listings as clean JSON with prices, specs, seller details, media, locations, and optional enrichment. Built for market research, price tracking, inventory monitoring, BI dashboards, and AI-agent workflows.

- **URL**: https://apify.com/fatihtahta/chrono24-scraper.md
- **Developed by:** [Fatih Tahta](https://apify.com/fatihtahta) (community)
- **Categories:** E-commerce, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 96.3% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 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 Scraper

**Slug:** `fatihtahta/chrono24-scraper`

### Overview

Chrono24 Scraper collects structured watch listing records from Chrono24, including listing identity, product details, pricing, shipping, availability, seller context, media, location text, and enrichment status when richer detail collection is enabled. [Chrono24](https://www.chrono24.com/) is a global marketplace for new, pre-owned, and collectible watches, making its public listing data useful for pricing research, sourcing analysis, inventory monitoring, and market intelligence. The actor supports direct Chrono24 URLs and detailed marketplace filters such as brand, model, production year, condition, seller type, location, currency, language, and watch specifications. Results are delivered as structured dataset records suitable for review, export, ETL pipelines, BI dashboards, AI-agent workflows, and downstream processing. The output contract groups related attributes into predictable objects so teams can use the data without relying on page-specific formatting. The actor is designed for repeatable data acquisition workflows where users need consistent inputs, stable JSON records, and run-level artifacts rather than manual marketplace review.

### What Makes This Actor Different

- **Watch-specific search controls:** Use direct URLs or Chrono24 catalog filters for brand, model, reference number, production year, case dimensions, bracelet details, clasp details, seller type, condition, availability, currency, and language.
- **Pipeline-ready product records:** Dataset rows use a grouped JSON contract with stable top-level identity fields and nested objects for product, pricing, shipping, availability, location, media, seller, metrics, merchandising, and source-specific attributes.
- **Deduplication-friendly identifiers:** `record_id` is the recommended idempotency key, with `url` and `source_context.fingerprint` available when present for secondary matching, audit, and repeated-run comparison.
- **Optional richer detail collection:** `enrich_data` lets users request deeper listing-level fields when the workflow needs richer watch specifications, descriptions, seller context, media galleries, or detail-page availability signals.
- **Run summary artifacts:** Each run writes `RUN-SUMMARY` and `RUN-REPORT.html` as key-value-store artifacts so operators can review saved-record counts, input scope, enrichment status, field coverage, warnings, and representative records without opening every dataset row.
- **Agentic and workflow-friendly handoff:** Optional `mcpConnectors` can send a concise post-run summary through user-authorized Apify MCP connectors after dataset and summary artifacts are ready. The dataset remains the primary output.
- **Field-preserving public contract:** The schema is designed to preserve meaningful watch, seller, pricing, media, and marketplace values in documented fields or grouped objects. Optional fields can still be absent when Chrono24 does not expose them for a specific record.

### Who Should Use This Actor

- **Watch market analysts:** compare public pricing, condition, currency, location, seller type, and availability across selected Chrono24 segments.
- **Marketplace and catalog teams:** collect structured watch listing records for internal catalogs, product matching, reference-number research, and inventory review.
- **Data engineering teams:** feed stable JSON records into warehouses, search indexes, dashboards, enrichment pipelines, and monitoring workflows.
- **AI agents and workflow automations:** run scoped collections, inspect summary artifacts, and route structured records into analysis, alerting, or review steps.
- **Sourcing and merchandising teams:** track brands, models, reference numbers, seller locations, pricing bands, and listing quality signals for buying or merchandising workflows.
- **Operations and monitoring teams:** schedule recurring runs to compare saved records, spot availability changes, and review field coverage over time.

### Common Use Cases

- **Market intelligence:** monitor supply, asking prices, currencies, locations, seller types, and availability for selected watch brands or models.
- **Reference-number tracking:** collect targeted records for exact references such as Rolex, Omega, Cartier, or other catalog identifiers.
- **Competitive monitoring:** repeat the same direct URL or filter inputs to compare public listing changes across runs.
- **Catalog enrichment:** add public watch attributes, media URLs, pricing, condition, and seller context to internal product or inventory systems.
- **Price-band analysis:** segment runs by `min_price`, `max_price`, currency, brand, model, and condition for cleaner downstream comparisons.
- **Listing-quality review:** use enriched records to inspect descriptions, media, specifications, availability, and seller details when available.
- **Recurring reporting:** schedule periodic runs and use dataset exports plus run summaries for dashboards, alerts, and trend analysis.
- **Agentic research workflows:** let a workflow agent collect a scoped dataset, read the run summary, deduplicate by `record_id`, and route records to the next system.

### Real-World Questions This Data Can Answer

- Which Chrono24 listings match a specific brand, model, reference number, location, condition, or price range?
- How do asking prices vary by currency, seller type, location, condition, or watch family?
- Which records are new, removed, or changed when compared with a previous dataset export?
- Which listings have richer media, seller context, or detail-level specifications available?
- Which brands, models, or reference numbers appear most often inside a monitored segment?
- Which records need review because price, seller, media, or location fields are missing?
- Which public listing signals are suitable for dashboards, alerting, enrichment, or sourcing queues?

### Quick Start

1. Choose a collection path: paste direct Chrono24 URLs in `url`, or build a structured marketplace search with supported filters.
2. Start with a narrow validation scope, such as one direct URL or one brand/model filter set, to validate record shape and field coverage.
3. Run the actor in Apify Console.
4. Open the dataset and inspect the first records for product, pricing, seller, media, and provenance fields.
5. Review `RUN-SUMMARY` or `RUN-REPORT.html` for saved-record counts, input scope, enrichment status, and warnings.
6. Broaden the search scope, add filters, enable `enrich_data`, export results, or schedule the actor once the output matches your workflow.

### Input Parameters

The actor accepts direct Chrono24 URLs, structured watch filters, an optional record limit, optional enrichment, and optional MCP connector delivery.

| Parameter | Type | Description | Default |
| --- | --- | --- | --- |
| `url` | array of strings | Direct Chrono24 search pages, brand/model pages, or individual listing URLs. Use for repeatable collection from known pages. | – |
| `brand` | array of strings | Chrono24 brand IDs selected from the input form. The schema includes 530 supported brand options, such as A. Lange & Söhne, ABP Paris, Baume & Mercier, Cartier, Omega, Patek Philippe, Rolex, and TAG Heuer. | – |
| `model` | array of strings | Chrono24 model IDs selected from the input form. The schema includes 1,000 supported model options, such as 1000, Moonswatch, Submariner, Speedmaster, Santos, Tank, Datejust, and other catalog values. | – |
| `production_year` | array of strings | Production years to include. Supported options span 1900 through 2028. | – |
| `location` | array of strings | Seller or listing country filters. The schema includes 127 country options, including Albania and United States of America. | – |
| `availability` | array of strings | Availability filters. Allowed values: `InStock`, `OnOrder`, `OnRequest`. | – |
| `new_used` | array of strings | Condition family filters. Allowed values: `new`, `used`, `NODATA`. | – |
| `condition` | array of strings | Detailed condition filters. The schema includes options such as New, Unworn, Mint, Fine, Fair, Scrap, and No details. | – |
| `seller_type` | array of strings | Seller type filters. Allowed values: `C24Direct`, `PrivateSeller`, `Dealer`. | – |
| `gender` | array of strings | Chrono24 audience category. Allowed values represent Men's watch/Unisex and Women's watch. | – |
| `watch_style` | array of strings | Watch style filters. The schema includes 36 options, including business watches, automatic watches, chronographs, diving watches, dress watches, and related styles. | – |
| `watch_type` | array of strings | Watch category filters. Allowed values represent Wristwatch, Pocket watch, and Other watch/clock. | – |
| `reference_number` | array of strings | Chrono24 reference-number options. The schema includes 1,000 supported values, useful for exact variant monitoring and valuation workflows. | – |
| `currency` | string | Display currency for generated searches. Allowed values: `AED`, `AUD`, `BHD`, `BRL`, `CAD`, `CHF`, `CLP`, `CNY`, `CZK`, `DKK`, `EUR`, `GBP`, `HKD`, `HRK`, `HUF`, `IDR`, `INR`, `JPY`, `KRW`, `KWD`, `MXN`, `MYR`, `NOK`, `NZD`, `OMR`, `PHP`, `PLN`, `QAR`, `RON`, `RUB`, `SEK`, `SGD`, `THB`, `TRY`, `TWD`, `USD`, `ZAR`. | `USD` |
| `language` | string | Page language for generated Chrono24 searches. Allowed values include English, Español, Deutsch, Français, Italiano, Nederlands, Português, Türkçe, 中文, 日本語, 한국어, and additional supported locales. | `en_US` |
| `sort_by` | string | Search sort order. Allowed values: `most_relevant`, `most_popular`, `most_recent`, `lowest_price`, `highest_price`. | `most_relevant` |
| `min_price` | integer | Minimum listing price in the selected currency. Use with `currency` for comparable price-band runs. | – |
| `max_price` | integer | Maximum listing price in the selected currency. Use with `min_price` to segment price bands. | – |
| `case_diameter` | array of strings | Case diameter filters in millimeters. The schema includes 109 options, including values such as 37 mm, 42 mm, and No details. | – |
| `lug_width` | array of strings | Lug width filters in millimeters. The schema includes 62 options, including 18 mm and No details. | – |
| `case_thickness` | array of strings | Case thickness filters in millimeters. The schema includes 48 options, including 13 mm and No details. | – |
| `functions_movement` | array of strings | Movement and function filters. The schema includes 27 options, including Movement: Automatic, Movement: No details, Function: Chronograph, and Function: Annual calendar. | – |
| `dial` | array of strings | Dial style and dial color filters. The schema includes 30 options, including Arabic numerals, No details, black, blue, and related dial values. | – |
| `case` | array of strings | Case material, bezel material, crystal, and water-resistance filters. The schema includes 71 options. | – |
| `bracelet` | array of strings | Bracelet or strap material and color filters. The schema includes 46 options. | – |
| `clasp` | array of strings | Clasp material and clasp type filters. The schema includes 20 options. | – |
| `additional_attributes` | array of strings | Additional watch attributes. The schema includes 30 options, such as Central seconds, Chronometer, Display back, Limited Edition, Power Reserve Display, Skeletonized, Smartwatch, Special Edition, and World time watch. | – |
| `limit` | integer | Maximum records to save for each source URL or generated search. Leave empty to collect all available results. | – |
| `enrich_data` | boolean | Enables richer detail-page fields when available, including deeper descriptions, watch specifications, seller context, media galleries, availability, and richer pricing context. | `true` |
| `mcpConnectors` | array of MCP connector resources | Optional user-authorized Apify MCP connectors for post-run summary delivery. The actor sends a concise run summary, not the full dataset. | `[]` |

### Choosing Inputs

Use `url` when you already know the Chrono24 pages to collect. This is best for saved searches, known brand or model pages, and individual listing refresh workflows.

Use structured filters when you need a targeted dataset. Narrower filters produce cleaner records for comparison and monitoring, while broader inputs are better for discovery. Segmenting runs by brand, model, location, condition, seller type, or price band usually makes downstream analysis easier.

Use `sort_by` to align the collection with the workflow: relevance for broad discovery, most recent for monitoring new public listings, and price sorting for valuation or market research. Use `currency` consistently across scheduled runs when comparing prices over time.

Enable `enrich_data` when richer listing-level details matter more than the fastest exploratory run. Leave it off for lightweight validation, monitoring, and search-result-level workflows.

Use `mcpConnectors` only after authorizing the destination in Apify and only when you want a concise run summary delivered after the dataset and run artifacts are ready.

### Input Recipes

- **Validation run:** use one direct URL or a narrow `brand` / `model` filter set, set `currency` to `USD`, choose `sort_by` as `most_relevant`, keep `enrich_data` disabled, and review a small focused segment first.
- **Direct URL refresh:** paste one or more Chrono24 search, brand, model, or listing URLs in `url`, keep filters minimal, and repeat the same input on a schedule for comparable results.
- **Targeted reference monitoring:** combine `brand`, `reference_number`, `condition`, `seller_type`, and a price range to track a precise watch segment.
- **Price-band analysis:** run separate inputs for each `min_price` / `max_price` range while keeping `currency`, `brand`, `model`, and `condition` consistent.
- **Recent-listing review:** use `sort_by` set to `most_recent` with a focused direct URL or brand/model combination, then compare exports across repeated runs.
- **Enrichment run:** provide known URLs or tightly scoped filters, enable `enrich_data`, and review the enriched fields and run summary before sending records into a production pipeline.

### Example Inputs

**Scenario: filtered validation run**

```json
{
  "brand": ["221"],
  "model": ["2846"],
  "currency": "USD",
  "language": "en_US",
  "sort_by": "most_relevant",
  "enrich_data": false
}
```

**Scenario: direct URL refresh**

```json
{
  "url": [
    "https://www.chrono24.com/rolex/index.htm?usedOrNew=used"
  ],
  "currency": "USD",
  "language": "en_US",
  "sort_by": "most_relevant",
  "enrich_data": false
}
```

**Scenario: targeted filtered collection**

```json
{
  "brand": ["194"],
  "seller_type": ["Dealer"],
  "condition": ["101", "1302"],
  "currency": "USD",
  "min_price": 1000,
  "max_price": 10000,
  "sort_by": "lowest_price",
  "enrich_data": true
}
```

### Output

#### Output Destination

The actor writes results to an Apify dataset as JSON records. The dataset is designed for direct consumption by analytics tools, ETL pipelines, AI agents, and downstream APIs with minimal post-processing.

The current public dataset contract contains one primary record shape: a Chrono24 watch product record with `record_type` set to `product`. Run-level summaries and reports are stored separately as key-value-store artifacts and are not dataset rows.

#### Record Envelope And Stable Identifiers

The recommended idempotency key is `record_id`. Use `url` as a secondary key when matching against public listing URLs, and use `source_context.fingerprint` when present for additional deduplication and audit workflows.

For upserts, sync by `record_id` first and update selected business fields such as title, pricing, availability, seller, media, and enrichment status. Stable identifiers make records easier to merge, deduplicate, compare, and sync across repeated runs. Provenance and freshness values live in `source_context`, which can include source identity, source URL, canonical URL, detail URL, enrichment status, scrape timestamp, and fingerprint.

#### Examples

**Example: product record (`record_type = "product"`)**

```json
{
  "record_type": "product",
  "record_id": "sample-chrono24-123456",
  "url": "https://www.chrono24.com/rolex/submariner-date--id123456.htm",
  "title": "Rolex Submariner Date 126610LN",
  "source_context": {
    "source_id": "chrono24",
    "source_domain": "chrono24.com",
    "source_url": "https://www.chrono24.com/rolex/index.htm?usedOrNew=used",
    "canonical_url": "https://www.chrono24.com/rolex/submariner-date--id123456.htm",
    "detail_url": "https://www.chrono24.com/rolex/submariner-date--id123456.htm",
    "enrichment_status": "enriched",
    "scraped_at": "2026-07-06T11:11:32.891089Z",
    "fingerprint": "sample-fingerprint-123456"
  },
  "entity": {
    "title": "Rolex Submariner Date 126610LN",
    "name": "Rolex Submariner Date 126610LN",
    "description": "Sample dealer-written watch description for public documentation.",
    "url": "https://www.chrono24.com/rolex/submariner-date--id123456.htm",
    "external_ids": {
      "chrono24_listing_id": "123456",
      "sku": "126610LN",
      "reference_number": "126610LN"
    },
    "status": "Item is in stock"
  },
  "product": {
    "product_id": "123456",
    "listing_id": "123456",
    "name": "Rolex Submariner Date 126610LN",
    "brand": "Rolex",
    "model": "Submariner Date",
    "reference_number": "126610LN",
    "sku": "126610LN",
    "production_year": "2024",
    "condition": "Used",
    "scope_of_delivery": "Original box, original papers",
    "gender": "Men's watch/Unisex",
    "description": "Sample product-level description.",
    "url": "https://www.chrono24.com/rolex/submariner-date--id123456.htm",
    "specifications": {
      "case_material": "Steel",
      "case_diameter": "41 mm",
      "water_resistance": "30 ATM",
      "crystal": "Sapphire crystal",
      "bracelet_material": "Steel",
      "bracelet_color": "Silver",
      "movement": "Automatic"
    }
  },
  "pricing": {
    "price": 12950.0,
    "price_text": "$12,950",
    "currency": "USD",
    "price_valid_until": "2026-08-01"
  },
  "shipping": {
    "shipping_price_text": "+ $99 insured shipping",
    "delivery_estimate": "Available now"
  },
  "availability": {
    "stock_status": "Item is in stock",
    "delivery_estimate": "Available now"
  },
  "offer": {
    "condition": "Used",
    "stock_status": "Item is in stock",
    "delivery_estimate": "Available now",
    "listed_at": "2026-07-06"
  },
  "location": {
    "display_location": "United States"
  },
  "media": {
    "primary_image_url": "https://img.chrono24.com/images/uhren/sample-watch-Square280.jpg",
    "image_urls": [
      "https://img.chrono24.com/images/uhren/sample-watch-Square280.jpg"
    ]
  },
  "seller": {
    "name": "Sample Watch Dealer",
    "seller_type": "Dealer",
    "country": "United States",
    "rating": 4.9
  },
  "metrics": {
    "review_count": 340,
    "watch_count": 120
  },
  "merchandising": {
    "certified_included": false,
    "is_popular": true,
    "badges": ["Trusted Seller"]
  },
  "attributes": {
    "style": "Diving watch",
    "watch_type": "Wristwatch"
  }
}
```

#### Run Summary And Artifacts

Each run writes stable key-value-store artifacts:

- **`RUN-SUMMARY`:** machine-readable JSON summary with timestamps, duration, source identity, input scope, saved-record totals, input modes, enrichment counts, field coverage counts, market breakdowns, representative records, warnings, and artifact keys.
- **`RUN-REPORT.html`:** human-readable report for review, handoff, and operational checks.
- **`RUN-SUMMARY-ERROR`:** best-effort diagnostic artifact when summary preparation fails after records have been saved.

Data teams and AI agents can use these artifacts as a run receipt: verify completion, compare recurring runs, check saved-record totals, inspect enrichment status, review coverage signals, route alerts, or decide whether a run needs follow-up. These artifacts complement the dataset; they do not replace dataset records.

### Field Reference

#### Record Envelope

- **record\_type** *(string, required)*: normalized record family. Chrono24 watch listings are saved as `product`.
- **record\_id** *(string, required)*: stable listing identifier or actor-generated fallback. Recommended idempotency key.
- **url** *(string, required)*: public Chrono24 listing URL.
- **title** *(string, required)*: display title for the listing.

#### `source_context`

- **source\_context.source\_id** *(string, optional)*: source identifier for the saved record.
- **source\_context.source\_domain** *(string, optional)*: domain associated with the listing.
- **source\_context.source\_url** *(string, optional)*: search, filter, direct, or listing URL that led to the record.
- **source\_context.canonical\_url** *(string, optional)*: normalized listing URL when available.
- **source\_context.detail\_url** *(string, optional)*: detail URL used for enriched records when available.
- **source\_context.enrichment\_status** *(string, optional)*: detail collection outcome such as `lightweight`, `enriched`, `failed`, `timed_out`, or `not_available`.
- **source\_context.scraped\_at** *(string, optional)*: timestamp when the record was produced.
- **source\_context.fingerprint** *(string, optional)*: stable fingerprint for deduplication and audit workflows when available.

#### `entity`

- **entity.title** *(string, optional)*: display title for the listing.
- **entity.name** *(string, optional)*: normalized entity name, usually matching the title.
- **entity.description** *(string, optional)*: listing description or watch notes when available.
- **entity.url** *(string, optional)*: public URL for the listing entity.
- **entity.external\_ids** *(object, optional)*: source-provided identifiers such as listing ID, SKU, or reference number.
- **entity.status** *(string, optional)*: listing status or availability text when available.

#### `product`

- **product.product\_id** *(string, optional)*: product or listing identifier.
- **product.listing\_id** *(string, optional)*: Chrono24 listing identifier.
- **product.name** *(string, optional)*: normalized product or listing name.
- **product.brand** *(string, optional)*: watch brand.
- **product.model** *(string, optional)*: watch model or model family.
- **product.reference\_number** *(string, optional)*: manufacturer or Chrono24 reference number.
- **product.sku** *(string, optional)*: source-provided SKU or product code.
- **product.production\_year** *(string, optional)*: production year text.
- **product.condition** *(string, optional)*: condition text from the listing.
- **product.scope\_of\_delivery** *(string, optional)*: box, papers, and delivery-package information.
- **product.gender** *(string, optional)*: Chrono24 audience category.
- **product.description** *(string, optional)*: product-level description or watch notes.
- **product.url** *(string, optional)*: public product/listing URL repeated for product-catalog consumers.
- **product.specifications.case\_material** *(string, optional)*: case material.
- **product.specifications.case\_diameter** *(string, optional)*: case diameter as source text.
- **product.specifications.water\_resistance** *(string, optional)*: water-resistance rating.
- **product.specifications.crystal** *(string, optional)*: crystal type or material.
- **product.specifications.bracelet\_material** *(string, optional)*: bracelet or strap material.
- **product.specifications.bracelet\_color** *(string, optional)*: bracelet or strap color.
- **product.specifications.movement** *(string, optional)*: movement type or movement text.

#### `pricing`, `shipping`, `availability`, And `offer`

- **pricing.price** *(number, optional)*: parsed numeric listing price.
- **pricing.price\_text** *(string, optional)*: display price text.
- **pricing.currency** *(string, optional)*: listing currency code.
- **pricing.price\_valid\_until** *(string, optional)*: source-provided price validity date when available.
- **shipping.shipping\_price\_text** *(string, optional)*: shipping cost or shipping terms as source text.
- **shipping.delivery\_estimate** *(string, optional)*: delivery or lead-time text.
- **availability.stock\_status** *(string, optional)*: source availability text.
- **availability.delivery\_estimate** *(string, optional)*: delivery availability text.
- **offer.condition** *(string, optional)*: offer condition text.
- **offer.stock\_status** *(string, optional)*: offer availability text.
- **offer.delivery\_estimate** *(string, optional)*: offer delivery or lead-time text.
- **offer.listed\_at** *(string, optional)*: listing date or publication text when available.

#### `location`, `media`, `seller`, `metrics`, `merchandising`, And `attributes`

- **location.display\_location** *(string, optional)*: human-readable listing or seller location. The dataset schema does not expose coordinates.
- **media.primary\_image\_url** *(string, optional)*: primary image URL.
- **media.image\_urls** *(array of strings, optional)*: image gallery URLs.
- **seller.name** *(string, optional)*: seller display name.
- **seller.seller\_type** *(string, optional)*: seller category such as Dealer or Private seller.
- **seller.country** *(string, optional)*: seller country when available.
- **seller.rating** *(string or number, optional)*: seller rating when available.
- **metrics.watch\_count** *(integer, optional)*: seller or listing-related watch count when available.
- **metrics.review\_count** *(integer, optional)*: seller review count when available.
- **merchandising.certified\_included** *(boolean, optional)*: whether Chrono24 certification is included.
- **merchandising.is\_popular** *(boolean, optional)*: whether the listing is marked as popular.
- **merchandising.badges** *(array of strings, optional)*: listing or seller badges.
- **attributes** *(object, optional)*: source-specific watch attributes that do not fit a stronger shared product group.

### Data Model Notes

- **Identity fields:** use `record_id` for upserts and repeated-run matching; use `url` and `source_context.fingerprint` as secondary keys when present.
- **Provenance fields:** `source_context` helps trace each record back to the public source URL, canonical URL, detail URL, scrape time, and enrichment status when available.
- **Business attributes:** `product`, `pricing`, `availability`, `shipping`, `seller`, `media`, and `location` carry the main user-facing value for analysis and review.
- **Metrics and counts:** `metrics` values should be treated as point-in-time public signals.
- **Nested objects:** related values are grouped to make JSON-first ETL, warehouse loading, and human review cleaner.
- **Optional fields:** null-check fields that depend on listing type, seller visibility, selected inputs, enrichment, or what Chrono24 exposes for a record.
- **Repeated runs:** compare records by stable key and store Apify run ID, input configuration, and export timestamp alongside the dataset when building audit trails.

### Data Quality, Guarantees, And Handling

- **Structured records:** results are normalized into predictable JSON objects for downstream use.
- **Field preservation:** meaningful schema-supported values should be kept in stable public fields or grouped objects instead of being silently discarded; optional source values may still be absent when Chrono24 does not expose them for a specific record.
- **Best-effort extraction:** fields may vary by region, availability, account visibility, UI experiments, or source-side changes.
- **Optional fields:** null-check in downstream code and dashboards.
- **Deduplication:** use `record_id` as the primary stable key, with `url` or `source_context.fingerprint` as secondary keys when useful.
- **Freshness:** results reflect the publicly available data at run time.
- **Repeated runs:** use the recommended idempotency key when syncing data into warehouses, CRMs, search indexes, vector stores, or monitoring systems.
- **Schema awareness:** downstream systems should rely on documented fields and handle newly missing optional fields gracefully.
- **Run receipts:** use `RUN-SUMMARY` and `RUN-REPORT.html` to audit record counts, enrichment status, coverage signals, warnings, and export readiness without treating them as replacement dataset records.

### Tips For Best Results

- Start with a narrow validation scope to confirm output shape before scaling up.
- Use one brand, model, reference number, price band, or country segment per run when you need cleaner comparison.
- Leave optional filters empty when the goal is broad discovery.
- Add filters gradually to understand how each field changes scope and field coverage.
- Use the same `currency` across recurring price-monitoring runs.
- Enable `enrich_data` only when richer listing-level details are required.
- Use `record_id` for deduplication when storing results over time.
- Review `RUN-SUMMARY` and `RUN-REPORT.html` before importing results into production dashboards or pipelines.

### How To Run On Apify

1. Open the actor in Apify Console.
2. Configure the available input fields for the watch segment you want to collect.
3. Review optional filters such as brand, model, price range, condition, seller type, and enrichment.
4. Click **Start** and wait for the run to finish.
5. Open the dataset and inspect the first records.
6. Download results in JSON, CSV, Excel, or another supported format.

### Agentic And API-First Usage

Chrono24 Scraper can be used as a structured data acquisition step inside larger automated workflows. It is well suited for workflows that select a search scope, collect watch listing records, validate the output contract, summarize the run, and upsert records into downstream systems.

Agent workflow pattern:

1. Generate or select a scoped input from the supported schema.
2. Run the actor manually, on a schedule, or through Apify platform automation.
3. Wait for completion and read the dataset records.
4. Validate records against the Field Reference.
5. Read `RUN-SUMMARY` or `RUN-REPORT.html` to verify counts, enrichment status, warnings, and export readiness.
6. Upsert records into the downstream system using `record_id`.
7. Trigger analysis, enrichment, alerts, BI refreshes, vector/search indexing, or human review.

Practical notes for agentic use:

- Keep prompts and automations grounded in the documented input parameters.
- Start with small validation runs before allowing broad automated collection.
- Feed the Field Reference and a small output sample to downstream AI steps.
- Feed run summary artifacts to downstream agents so they can reason about completion, record counts, enrichment status, and follow-up actions.
- Treat optional fields as nullable instead of asking agents to infer missing values.
- Store run ID, input configuration, and dataset export metadata outside the record when building audit trails.
- For tools such as Claude, Codex, internal copilots, or workflow agents, pass the input schema, Field Reference, idempotency key, and one representative output example rather than the full README when context is limited.

### Scheduling & Automation

#### Scheduling

**Automated Data Collection**

Schedule recurring runs to keep watch listing datasets fresh for monitoring, reporting, and comparison workflows. Reuse the same input configuration when you need comparable results across time.

- Navigate to **Schedules** in Apify Console
- Create a new schedule, such as daily, weekly, or custom cron
- Configure input parameters
- Enable notifications for run completion
- Add webhooks for automated processing

#### Integration Options

- **BI dashboards:** monitor pricing, availability, seller types, brands, models, and geographic distribution over time.
- **Warehouses and data lakes:** store normalized watch listing records for historical analysis and market intelligence.
- **Webhooks:** trigger validation, notification, enrichment, or ingestion workflows after each completed run.
- **MCP connectors:** authorize a connector in Apify, select it in `mcpConnectors`, and use the delivered run summary in the destination tool.
- **Google Sheets or Airtable:** review smaller exports, triage listings, and share selected records with non-technical stakeholders.
- **Search or vector indexes:** index titles, descriptions, product attributes, and seller context for discovery and AI-assisted research.
- **Alerts and reporting:** compare recurring runs and notify teams when selected brands, price bands, or availability signals change.

### Export Formats And Downstream Use

- **JSON:** for APIs, applications, AI agents, and data pipelines that preserve nested objects.
- **CSV or Excel:** for spreadsheet workflows, stakeholder review, and lightweight analysis.
- **API access:** for automated ingestion into internal systems.
- **BI and warehouses:** for reporting, dashboards, historical analysis, and monitoring.
- **Search or vector indexes:** for discovery, semantic search, retrieval workflows, and agent context.

### Downstream Pipeline Guide

- **Idempotency:** use `record_id` for upserts; keep `url` and `source_context.fingerprint` as secondary matching signals when present.
- **Null handling:** treat optional fields as nullable, especially enriched details, seller metrics, media galleries, shipping, and availability text.
- **Type handling:** preserve numbers, booleans, arrays, and nested objects when exporting to JSON-first systems.
- **Flattening:** if exporting to CSV or Excel, flatten nested objects deliberately and keep the original JSON export for full fidelity.
- **Partitioning:** store run date, input segment, brand, model, price band, country, or workflow name alongside records for easier analysis.
- **Change detection:** compare repeated runs by `record_id` and selected business fields such as price, currency, availability, seller, location, and title.
- **Quality checks:** monitor record count, required identifiers, duplicate rate, enrichment status, and fill rates for important optional groups.
- **Human review:** route records with missing critical fields, unusual prices, changed availability, or unexpected seller/location values into a review queue.
- **Retention:** decide how long to keep raw exports versus normalized warehouse tables based on your use case.

### Performance And Coverage Expectations

Current public output performance should be treated as workload-dependent. The available current validation evidence confirms schema validity, dataset/KV artifact writing, and summary generation; it does not provide a representative measured benchmark for normal production-scale listing output under every input shape.

Estimated guidance:

- **Small runs (< 1,000 outputs):** about 3-5 minutes.
- **Medium runs (1,000-5,000 outputs):** about 5-15 minutes.
- **Large runs (5,000+ outputs):** about 15-30 minutes.

Execution time varies based on filters, result volume, Chrono24 availability, page response size, selected sort order, and how much information is returned per record. Highly filtered runs can finish faster, while broad discovery or detail-rich records may take longer. Enable `enrich_data` only when richer listing-level details are useful for the workflow.

### Limitations

- Availability depends on what Chrono24 publicly exposes at run time.
- Some optional fields may be missing on sparse listings or records without detail-level information.
- Very broad searches may take longer and can be easier to manage when split into smaller input segments.
- Region, language, account visibility, seller type, and listing availability can affect visible values.
- Target-side changes can affect field availability or naming.
- The actor provides structured public listing data, not investment advice, valuation advice, legal advice, or guaranteed market completeness.

### Troubleshooting

- **No results returned:** check direct URLs, filters, price ranges, and whether Chrono24 has public records matching the selected criteria.
- **Fewer results than expected:** broaden filters or verify that enough matching public listings exist.
- **Some fields are empty:** optional fields depend on what each listing publicly provides and whether richer detail collection is enabled.
- **Duplicate-looking records:** compare `record_id` first, then review `url` and `source_context.fingerprint` when present.
- **Run takes longer than expected:** reduce scope for validation or split broad collection into smaller segments.
- **Output changed:** compare the current output with the Field Reference and include a small sample when reporting the issue.
- **Downstream import failed:** check JSON validity, nullable fields, nested objects, and whether the destination expects flattened columns.
- **MCP summary did not arrive:** confirm that the connector is authorized in Apify and selected in `mcpConnectors`; the dataset and key-value-store artifacts remain the primary outputs.

### FAQ

**What data does this actor collect?**\
It collects public Chrono24 watch listing records, including listing identity, product details, pricing, availability, shipping, location text, media, seller context, metrics, and enrichment status when available.

**Can I filter by brand, model, reference number, price, or status?**
Yes. The input schema supports direct URLs, brand, model, production year, location, availability, new/used state, condition, seller type, watch style, watch type, reference number, price range, currency, language, and additional watch specification filters.

**Why did I receive fewer results than expected?**\
The selected criteria may have fewer visible public matches, or the source may return fewer records for that segment.

**Where can I find the run summary?**\
Open the run's key-value store and look for `RUN-SUMMARY` and `RUN-REPORT.html`.

**How should I choose my first run scope?**\
Start with one direct URL or one narrow filter set, inspect the dataset shape, then broaden the search or add more segments after confirming the output matches your use case.

**Can I schedule recurring runs?**\
Yes. Use Apify Schedules to run the same input daily, weekly, or on a custom schedule.

**How do I avoid duplicates across runs?**\
Use `record_id` as the primary unique key. Keep `url` and `source_context.fingerprint` as secondary keys when present.

**What is the best field to use as a unique key?**\
Use `record_id`.

**Can I use the output with AI agents or automated workflows?**\
Yes. Use the input schema, Field Reference, representative output example, and run summary artifacts to keep automated workflows grounded in the documented contract.

**Can I export the data to CSV, Excel, or JSON?**\
Yes. Apify datasets support common export formats, including JSON, CSV, and Excel.

**Does this actor collect private data?**\
The actor is intended for publicly available Chrono24 listing information. Users are responsible for using the data lawfully and responsibly.

**What should I include when reporting an issue?**\
Include the run ID, redacted input, expected behavior, actual behavior, a small output sample if useful, and the export or downstream destination if the issue is pipeline-related.

### Compliance & Ethics

#### Responsible Data Collection

This actor collects publicly available watch listing information from Chrono24 for legitimate business purposes, including:

- **Watch and marketplace** research and market analysis
- Public pricing, availability, and sourcing workflows
- Catalog enrichment, monitoring, and operational reporting

This section is informational and not legal advice.

#### Best Practices

- Use collected data in accordance with applicable laws, regulations, and the target site's terms.
- Respect individual privacy and personal information.
- Use data responsibly and avoid disruptive or excessive collection.
- Do not use this actor for spamming, harassment, discrimination, or other harmful purposes.
- Follow relevant data protection requirements where applicable, such as GDPR, CCPA, or sector-specific rules.
- Review your own retention, access control, and data-sharing policies before operationalizing the dataset.

### Support

For help, use the actor page or Issues section. Include the input used with sensitive values redacted, the Apify run ID, expected versus actual behavior, a small output sample when relevant, and the downstream destination or export format if the issue is pipeline-related.

# Actor input Schema

## `url` (type: `array`):

Paste one or more supported Chrono24 URLs, such as a search results page, a brand or model listing page, or an individual watch listing. Use direct URLs for precise, repeatable collection; structured filters below can also create additional search targets when filled.

## `brand` (type: `array`):

Choose one or more Chrono24 brands to build a focused marketplace search. Brand filters are useful for competitive tracking, inventory research, and repeatable exports for a known manufacturer set.

## `model` (type: `array`):

Choose one or more model families when you want a narrower watch search than brand alone. This is useful for monitoring specific lines such as Submariner, Speedmaster, Nautilus, or Tank using Chrono24 catalog filters.

## `production_year` (type: `array`):

Select one or more production years when the age of the watch matters for sourcing, valuation, or collection monitoring. Leave empty to include listings regardless of production year.

## `location` (type: `array`):

Select one or more seller locations to focus the search on particular markets. Use this for regional price comparison, import planning, or monitoring inventory available from specific countries.

## `availability` (type: `array`):

Choose whether to include in-stock watches, watches that need to be procured, or listings available on request. Leave empty when availability should not narrow the dataset.

## `new_used` (type: `array`):

Select new/unworn, used, or listings without status details. Use this to separate retail-like inventory from pre-owned marketplace listings.

## `condition` (type: `array`):

Choose condition levels such as new, very good, good, fair, or incomplete. This helps keep pricing analysis and downstream comparisons aligned to comparable listing quality.

## `seller_type` (type: `array`):

Limit results to Chrono24 Direct, private sellers, professional dealers, or any combination. This is useful when comparing dealer inventory against private-market listings.

## `gender` (type: `array`):

Select the Chrono24 audience category, such as men's/unisex or women's watches. Leave empty when the search should include all audience categories.

## `watch_style` (type: `array`):

Select one or more Chrono24 style categories such as diving watches, chronographs, dress watches, or business watches. Use this when the buying theme matters more than a single brand or model.

## `watch_type` (type: `array`):

Choose wristwatches, pocket watches, or other watch and clock categories. Leave empty for the broadest Chrono24 watch search.

## `reference_number` (type: `array`):

Choose one or more Chrono24 reference-number options when you need highly precise collection for exact variants. Reference numbers are kept as identifiers and are best for valuation, backfills, and repeatable monitoring.

## `currency` (type: `string`):

Select the currency Chrono24 should use when showing listing prices in generated searches. Use a consistent currency across scheduled runs or ETL exports when comparing prices over time.

## `language` (type: `string`):

Select the language used for generated Chrono24 search pages. Keep one language across repeat runs when you want stable text values for downstream processing.

## `sort_by` (type: `string`):

Select the Chrono24 sort order for searches created from direct URLs or structured filters. Use relevance for broad discovery, most recent for monitoring new listings, or price sorting for market research.

## `min_price` (type: `integer`):

Enter the lowest price to include in generated searches. Use this to exclude low-value listings or accessories when building cleaner exports for valuation and market analysis.

## `max_price` (type: `integer`):

Enter the highest price to include in generated searches. Use this to keep broad searches within a target budget, collection tier, or downstream import scope.

## `case_diameter` (type: `array`):

Select one or more case sizes in millimeters. This helps narrow searches to wearable size ranges, collection preferences, or comparable watch variants.

## `lug_width` (type: `array`):

Select one or more lug-width values in millimeters when strap compatibility or case proportions matter for the collection scope. Leave empty when lug width is not a requirement.

## `case_thickness` (type: `array`):

Select one or more case-thickness values in millimeters. Use this for searches where profile, fit, or variant comparison matters.

## `functions_movement` (type: `array`):

Select movement types such as automatic, manual winding, quartz, or solar, and functions such as chronograph, GMT, moon phase, date, or tourbillon. Use this for feature-based sourcing and analytics.

## `dial` (type: `array`):

Choose dial numeral styles and colors to focus the search on specific variants. This is useful for collectors, inventory matching, and downstream variant analysis.

## `case` (type: `array`):

Select case materials, bezel materials, crystal types, or water-resistance levels. Use these filters when physical specifications are important for sourcing, valuation, or product matching.

## `bracelet` (type: `array`):

Select band materials or colors to narrow the search to specific configurations. This is useful when bracelet condition, metal type, or strap style affects value or matching.

## `clasp` (type: `array`):

Choose clasp materials or clasp styles when the bracelet configuration matters for valuation, authenticity review, or inventory matching.

## `additional_attributes` (type: `array`):

Select source-specific attributes such as limited edition, chronometer, display back, power reserve display, screw-down crown, or special edition. Use these filters for high-intent sourcing and more precise downstream segmentation.

## `enrich_data` (type: `boolean`):

Enable this when you need fuller records for analysis or ETL handoff. Leave it off for faster validation runs, lightweight monitoring, or cases where search-result fields are enough.

## `limit` (type: `integer`):

Maximum records to save for each source URL or keyword search. Use a bounded value for validation, recurring monitors, and ETL batches; leave empty when the actor should collect all available results.

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

Choose user-authorized MCP connectors for optional post-run delivery, notifications, or workflow handoff. Leave empty to only save results to the Apify dataset and key-value store.

## Actor input object example

```json
{
  "url": [
    "https://www.chrono24.com/rolex/gmt-master-ii--mod4.htm"
  ],
  "currency": "USD",
  "language": "en_US",
  "sort_by": "most_relevant",
  "enrich_data": true,
  "limit": 100,
  "mcpConnectors": []
}
```

# Actor output Schema

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

Grouped Chrono24 watch product records saved by this run.

## `runSummaryJson` (type: `string`):

Machine-readable end-of-run summary with saved-record totals, input scope, enrichment status, coverage counts, market breakdowns, warnings, and representative records.

## `runSummaryHtml` (type: `string`):

Human-readable HTML report with key Chrono24 run totals, enrichment status, coverage counts, market breakdowns, warnings, and representative records.

# 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 = {
    "url": [
        "https://www.chrono24.com/rolex/gmt-master-ii--mod4.htm"
    ],
    "limit": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("fatihtahta/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 = {
    "url": ["https://www.chrono24.com/rolex/gmt-master-ii--mod4.htm"],
    "limit": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("fatihtahta/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 '{
  "url": [
    "https://www.chrono24.com/rolex/gmt-master-ii--mod4.htm"
  ],
  "limit": 100
}' |
apify call fatihtahta/chrono24-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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