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

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

Scenario: direct URL refresh

{
  "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

{
  "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")

{
  "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.