# Chrono24 Watch Listings Scraper (`automation-lab/chrono24-watch-listings-scraper`) Actor

⌚ Export public Chrono24 watch listings with typed prices, references, seller locations, images, pagination, and optional detail enrichment for comps, sourcing, and inventory monitoring.

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

## Pricing

Pay per event

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Listings Scraper

Extract public Chrono24 watch listings into a clean dataset for inventory monitoring, price research, valuation, and marketplace analysis.

The actor accepts Chrono24 search, brand, and model result pages, follows pagination, and saves one record per unique listing. It captures prices, references, seller locations, images, and source metadata without requiring a Chrono24 login.

- ⌚ Monitor Rolex, Omega, Patek Philippe, and other brand inventory
- 💵 Build current asking-price and comparable-listing datasets
- 🌍 Compare dealer and private-seller supply across locations
- 🔁 Schedule recurring exports for inventory and price changes
- 🔎 Optionally enrich cards with structured detail-page data

### What does Chrono24 Watch Listings Scraper do?

Chrono24 Watch Listings Scraper opens the public result pages you provide and exports their watch cards as JSON, CSV, Excel, XML, or RSS through Apify datasets.

For each listing it can collect:

- stable Chrono24 listing ID and canonical URL;
- watch title, recognized brand, and model;
- public reference or card detail text;
- numeric price, currency, and displayed price;
- shipping text and numeric shipping price when shown;
- condition and production year when exposed on the card;
- dealer or private-seller classification;
- seller location and watch image URL;
- promotion badge, source page, source URL, and scrape time;
- optional JSON-LD description, exact reference, and availability.

The actor follows the visible **Next** link and deduplicates listings by their numeric Chrono24 ID.

### Who should use this Chrono24 scraper?

#### Watch dealers and resellers

Track competing inventory, asking prices, reference numbers, and seller locations. Run the same URLs daily to identify newly listed or removed watches.

#### Collectors and buyers

Build a shortlist of comparable watches before a purchase. Export records to a spreadsheet and compare price, shipping, year, condition, and seller geography.

#### Valuation analysts

Create repeatable snapshots for reference-level price research. Use `sourceUrl`, `sourcePage`, and `scrapedAt` to audit where and when each comparable was observed.

#### Marketplaces and data teams

Feed structured public listing records into dashboards, warehouses, alerts, or internal valuation tools without maintaining a browser scraper.

### Why use this actor?

Chrono24 is protected by browser checks, and basic HTTP requests can return a challenge instead of listing data. This actor uses a full browser under Xvfb, a realistic context, bounded session rotation, and Apify Proxy support.

You also get:

- ✅ typed, export-ready dataset fields;
- ✅ strict Chrono24 URL validation;
- ✅ global `maxItems` cost control;
- ✅ per-URL pagination limits;
- ✅ stable ID deduplication;
- ✅ non-zero failure on total extraction failure;
- ✅ optional detail enrichment rather than mandatory slow requests;
- ✅ integrations with the Apify API, schedules, webhooks, MCP, and storage.

### What Chrono24 data can you extract?

| Field | Type | Description |
|---|---|---|
| `listingId` | string | Stable numeric Chrono24 listing ID |
| `url` | string | Canonical public listing URL |
| `title` | string | Watch title from the result card |
| `brand` | string | Recognized manufacturer when available |
| `model` | string | Model text derived from the card title |
| `referenceNumber` | string | Card detail/reference text or enriched reference |
| `price` | number | Numeric asking price when public |
| `currency` | string | Price currency, such as `USD` |
| `priceText` | string | Original displayed price or “Price on request” |
| `shippingPrice` | number | Numeric shipping amount when shown |
| `shippingText` | string | Original shipping label |
| `condition` | string | Condition hint when exposed |
| `year` | number | Production year found on the card |
| `sellerType` | string | `dealer` or `private` |
| `sellerLocation` | string | Public seller country/location |
| `imageUrl` | string | Watch image URL |
| `badge` | string | Public card badge such as “Popular” |
| `isPromoted` | boolean | Whether a badge indicates promotion |
| `detailsEnriched` | boolean | Whether detail JSON-LD was added |
| `description` | string | Optional structured detail description |
| `availability` | string | Optional detail availability |
| `sourceUrl` | string | Input or pagination URL that produced the row |
| `sourcePage` | number | Page number within that input |
| `scrapedAt` | string | UTC ISO timestamp |

Optional values are omitted when Chrono24 does not expose them; the actor does not invent missing data.

### How to scrape Chrono24 watch listings

1. Open the actor input page.
2. Add one or more public Chrono24 search, brand, or model result URLs.
3. Set **Maximum watch listings** to control total output.
4. Set **Maximum pages per URL** to bound pagination.
5. Leave detail enrichment off for fast monitoring, or enable it for richer records.
6. Keep direct browser access for the tested low-cost default; enable a proxy only if your environment is challenged.
7. Click **Start**.
8. Export the resulting dataset as JSON, CSV, Excel, XML, or RSS.

A low-cost first run uses one URL, one page, and five listings.

### Input parameters

| Parameter | Type | Default | Purpose |
|---|---|---:|---|
| `startUrls` | array | Rolex result page | Chrono24 search, brand, or model pages |
| `maxItems` | integer | 20 | Global unique-listing limit |
| `maxPagesPerUrl` | integer | 3 | Pagination limit for every seed URL |
| `includeDetails` | boolean | false | Visit details for JSON-LD enrichment |
| `navigationTimeoutSecs` | integer | 60 | Per-page browser timeout |
| `maxSessionRetries` | integer | 2 | Browser/proxy rotations after challenges |
| `proxyConfiguration` | object | Direct access | Optional proxy settings for challenged environments |

Individual listing-detail URLs are intentionally rejected as start URLs. This keeps every output row within the same listing-search product contract.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.chrono24.com/rolex/index.htm" },
    { "url": "https://www.chrono24.com/omega/index.htm" }
  ],
  "maxItems": 40,
  "maxPagesPerUrl": 2,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

For a detail-enriched valuation sample, set `includeDetails` to `true` and start with a low `maxItems` value.

### Example output

```json
{
  "listingId": "47173309",
  "url": "https://www.chrono24.com/rolex/yacht-master-16622-platinum-grey-dial-stainless-steel-40--id47173309.htm",
  "title": "Rolex Yacht-Master 40",
  "brand": "Rolex",
  "model": "Yacht-Master 40",
  "referenceNumber": "16622 PLATINUM Grey Dial Stainless Steel 40",
  "price": 10000,
  "currency": "USD",
  "priceText": "$10,000",
  "shippingPrice": 99,
  "sellerType": "dealer",
  "sellerLocation": "United States of America",
  "isPromoted": true,
  "detailsEnriched": false,
  "sourcePage": 1,
  "scrapedAt": "2026-07-22T07:55:03.920Z"
}
```

Values change as the marketplace changes. The example illustrates the schema rather than guaranteeing a specific live offer.

### How much does it cost to scrape Chrono24 listings?

This actor uses pay-per-event pricing:

- one small **Start** charge per run;
- one **Watch listing** charge for each unique dataset row.

The Console always shows the current exact event prices before a run. You control spend with `maxItems` and `maxPagesPerUrl`; detail enrichment also increases browser and proxy usage, so test that mode with a small limit first.

The free Apify plan can be used for small evaluations subject to your available platform credits. For recurring production monitoring, estimate cost from the item limit and the current tier price shown in Console.

### Inventory and price-monitoring workflow

Run a stable set of result URLs on a schedule and store each dataset snapshot.

A typical workflow is:

1. schedule the actor daily or hourly;
2. export `listingId`, `price`, `sellerLocation`, and `scrapedAt`;
3. join the new snapshot to the previous snapshot by `listingId`;
4. flag new IDs, removed IDs, and changed prices;
5. send changes to Slack, email, a webhook, or a database.

Because listings are deduplicated by stable ID, multiple overlapping result URLs can be supplied in one run.

### Tips for reliable Chrono24 extraction

- 🎯 Start with exact brand, model, or filtered search URLs.
- 📉 Keep `maxItems` low while validating a new workflow.
- 📄 Use one or two pages unless deeper inventory coverage is required.
- 🔎 Enable detail enrichment only when descriptions or availability are needed.
- 🌐 Use the tested direct default first; enable Apify Proxy only when needed.
- 🔁 Let the actor rotate sessions rather than adding aggressive concurrency.
- 🧾 Use the displayed `priceText` when a numeric price is unavailable.
- 🕒 Compare `scrapedAt` values when building historical snapshots.

Chrono24 can change its page structure or challenge behavior. If a run fails, retry once with the default settings and inspect the log before increasing limits.

### Apify integrations

#### Google Sheets and Excel

Export CSV or Excel from the dataset, or connect the dataset to a spreadsheet automation for recurring comparable-price reports.

#### Webhooks and alerts

Trigger a webhook when a run succeeds. Compare the new dataset against the previous run and alert on new listings or price reductions.

#### Data warehouses

Pull dataset items through the API into BigQuery, Snowflake, PostgreSQL, or your preferred lakehouse. Use `listingId` as the marketplace key and `scrapedAt` as the snapshot timestamp.

#### Zapier and Make

Start runs from a workflow, wait for completion, then route new listing records to a CRM, notification channel, or review queue.

### Use the actor through the JavaScript API

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/chrono24-watch-listings-scraper').call({
  startUrls: [{ url: 'https://www.chrono24.com/rolex/index.htm' }],
  maxItems: 20,
  maxPagesPerUrl: 1,
  includeDetails: false,
  proxyConfiguration: { useApifyProxy: false }
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use the actor through the Python API

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/chrono24-watch-listings-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.chrono24.com/omega/index.htm'}],
    'maxItems': 20,
    'maxPagesPerUrl': 1,
    'includeDetails': False,
    'proxyConfiguration': {'useApifyProxy': False},
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### Use the actor with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~chrono24-watch-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.chrono24.com/rolex/index.htm"}],
    "maxItems": 20,
    "maxPagesPerUrl": 1,
    "proxyConfiguration": {"useApifyProxy": false}
  }'
```

Fetch dataset items after the run finishes using the `defaultDatasetId` returned by the run API.

### Use Chrono24 data with MCP and AI agents

Connect the actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/chrono24-watch-listings-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this HTTP MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/chrono24-watch-listings-scraper"
    }
  }
}
```

Example prompts for your agent:

- “Scrape the first 20 Rolex listings from Chrono24 and summarize asking prices.”
- “Export current Omega listings and group them by seller location.”
- “Create a comparable set for these Chrono24 result URLs and flag prices below the median.”
- “Run an enriched five-item sample and summarize references and availability.”

### Limitations

- Only public `chrono24.com` result pages are supported.
- Login-only data, saved searches, messaging, and account data are not accessed.
- Fields absent from public cards are omitted rather than inferred.
- Detail enrichment is slower and may fail for individual listings; useful card records are preserved.
- Marketplace changes can affect selectors, availability, or challenge behavior.
- Asking prices are not completed transaction prices and should not be treated as appraisals.
- Currency reflects the public page presentation; no currency conversion is performed.

### Is it legal to scrape Chrono24?

This actor extracts public marketplace information. Web scraping laws and contractual requirements vary by country and use case.

Use the actor responsibly:

- collect only data you have a lawful purpose to process;
- respect applicable terms, database rights, copyright, and privacy rules;
- avoid excessive request volume;
- do not use output for spam, harassment, or discriminatory decisions;
- consult qualified counsel for regulated or high-risk uses.

The actor does not bypass login, access private account information, or send messages to sellers.

### Troubleshooting

#### Why did the run report a Chrono24 challenge?

Use the tested direct default and the standard retry settings first. If direct access is challenged in your environment, enable Apify Proxy or provide a custom proxy. Avoid high limits until a small run succeeds.

#### Why is `price` missing?

Chrono24 may display “Price on request.” The original `priceText` remains available, but the actor does not invent a numeric price.

#### Why is `detailsEnriched` false when enrichment was enabled?

The detail page may not expose parseable Product JSON-LD or may have failed independently. The actor preserves the valid result-card record instead of discarding it.

#### Why was my URL rejected?

The URL must use `chrono24.com`, end in a public result-page `.htm` route, and not be an individual `--id123.htm` listing. Open the desired public result page in Chrono24 and copy that URL.

### FAQ

#### Does this scraper require a Chrono24 account?

No. It reads public listing result pages and optional public detail metadata anonymously.

#### Can it scrape multiple brands in one run?

Yes. Add multiple brand or search URLs. `maxItems` applies globally, and duplicate listing IDs are emitted once.

#### Does it support pagination?

Yes. Set `maxPagesPerUrl`; the actor follows Chrono24's visible **Next** link.

#### Can I monitor prices over time?

Yes. Schedule repeated runs and compare datasets by `listingId`. Keep each snapshot's `price`, `priceText`, and `scrapedAt`.

#### Are prices guaranteed to be accurate appraisals?

No. They are public asking prices at scrape time. Validate any valuation decision with appropriate market and professional context.

### Related watch and marketplace scrapers

- [Bob's Watches Listings Scraper](https://apify.com/automation-lab/bobs-watches-listings-scraper) — compare dealer-owned Rolex inventory.
- [Jomashop Luxury Watch Listings Scraper](https://apify.com/automation-lab/jomashop-luxury-watch-listings-scraper) — extract retail luxury-watch listings.
- [Bring a Trailer Auctions Scraper](https://apify.com/automation-lab/bringatrailer-auctions-scraper) — monitor collectible auction inventory.
- [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) — broaden marketplace price research.

Use related actors only when their source fits your workflow; each marketplace has a different pricing and seller context.

# Actor input Schema

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

Add public Chrono24 search, brand, or model result URLs. Individual listing-detail URLs are not accepted here.

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

Stop after saving this many unique Chrono24 watch listings across all input URLs.

## `maxPagesPerUrl` (type: `integer`):

Limit pagination for each Chrono24 result URL.

## `includeDetails` (type: `boolean`):

Open each listing page to add structured description, exact reference, and availability when exposed. This is slower and uses more proxy traffic.

## `navigationTimeoutSecs` (type: `integer`):

Maximum time to wait for each Chrono24 page.

## `maxSessionRetries` (type: `integer`):

Rotate the browser and proxy session after a challenge or navigation failure.

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

Direct browser access is the tested default. Enable Apify Proxy or provide custom proxy URLs only when your environment is challenged.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.chrono24.com/rolex/index.htm"
    }
  ],
  "maxItems": 5,
  "maxPagesPerUrl": 1,
  "includeDetails": false,
  "navigationTimeoutSecs": 60,
  "maxSessionRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Unique watch listings with prices, references, sellers, images, source metadata, and optional detail enrichment.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.chrono24.com/rolex/index.htm"
        }
    ],
    "maxItems": 5,
    "maxPagesPerUrl": 1,
    "includeDetails": false,
    "navigationTimeoutSecs": 60,
    "maxSessionRetries": 2,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/chrono24-watch-listings-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.chrono24.com/rolex/index.htm" }],
    "maxItems": 5,
    "maxPagesPerUrl": 1,
    "includeDetails": False,
    "navigationTimeoutSecs": 60,
    "maxSessionRetries": 2,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/chrono24-watch-listings-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 '{
  "startUrls": [
    {
      "url": "https://www.chrono24.com/rolex/index.htm"
    }
  ],
  "maxItems": 5,
  "maxPagesPerUrl": 1,
  "includeDetails": false,
  "navigationTimeoutSecs": 60,
  "maxSessionRetries": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/chrono24-watch-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Chrono24 Watch Listings Scraper",
        "description": "⌚ Export public Chrono24 watch listings with typed prices, references, seller locations, images, pagination, and optional detail enrichment for comps, sourcing, and inventory monitoring.",
        "version": "0.1",
        "x-build-id": "jQNfgFaBYp57mwrrQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~chrono24-watch-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-chrono24-watch-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~chrono24-watch-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-chrono24-watch-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~chrono24-watch-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-chrono24-watch-listings-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "⌚ Chrono24 result pages",
                        "type": "array",
                        "description": "Add public Chrono24 search, brand, or model result URLs. Individual listing-detail URLs are not accepted here.",
                        "default": [
                            {
                                "url": "https://www.chrono24.com/rolex/index.htm"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum watch listings",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after saving this many unique Chrono24 watch listings across all input URLs.",
                        "default": 20
                    },
                    "maxPagesPerUrl": {
                        "title": "Maximum pages per URL",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Limit pagination for each Chrono24 result URL.",
                        "default": 3
                    },
                    "includeDetails": {
                        "title": "🔎 Enrich from listing pages",
                        "type": "boolean",
                        "description": "Open each listing page to add structured description, exact reference, and availability when exposed. This is slower and uses more proxy traffic.",
                        "default": false
                    },
                    "navigationTimeoutSecs": {
                        "title": "Navigation timeout (seconds)",
                        "minimum": 15,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum time to wait for each Chrono24 page.",
                        "default": 60
                    },
                    "maxSessionRetries": {
                        "title": "Browser session retries",
                        "minimum": 0,
                        "maximum": 4,
                        "type": "integer",
                        "description": "Rotate the browser and proxy session after a challenge or navigation failure.",
                        "default": 2
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Direct browser access is the tested default. Enable Apify Proxy or provide custom proxy URLs only when your environment is challenged.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```