# Chrono24 Market Intel: Dealer Leads + Price Index (`xtracto/chrono24-market-intel`) Actor

Chrono24 watch-market intel: verified-dealer leads (name, location, phone, rating, listing count) and a live price-index snapshot (median/range) for any watch model or reference.

- **URL**: https://apify.com/xtracto/chrono24-market-intel.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.67 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Chrono24 Market Intel: Dealer Leads + Price Index

Search [Chrono24](https://www.chrono24.com/) for any watch brand, model, or reference number and get either a live asking-price snapshot for that watch, or a list of the verified dealers currently selling it — complete with contact details, ratings, and listing counts.

### Why use this actor

- **Real-time price index** — median, min, max, and average asking price computed from watches that are for sale right now.
- **Dealer leads with contact info** — dealer name, city/country, phone, and (where the dealer publishes it) fax, all pulled from Chrono24's own dealer profile pages.
- **Verified-dealer signal** — flags dealers that carry Chrono24's "Trusted Seller" badge, plus their rating, review count, and total active/sold listings.
- **Dealer-vs-private breakdown** — every listing is tagged by seller type, so the price index also tells you what share of the market is professional dealers.
- **No account, no API key** — works straight from public pages.
- **Stable JSON output** — the same field names every run, ready for spreadsheets, databases, or pipelines.

### How it works

1. You give the actor a watch keyword (`Rolex Submariner`, or narrow it down with a reference number like `Rolex Submariner 116610LN`) and a mode.
2. In **price-index** mode, the actor pulls the live search results for that keyword and saves each one as a listing record, then computes one summary record — median/min/max/avg price, sample size, and the dealer/private-seller split.
3. In **dealer-search** mode, the actor pulls the same search results, keeps only the dealer-listed watches, opens each watch's page to find its dealer, then opens that dealer's own profile page for its contact and business details. Each unique dealer becomes one lead record.
4. If a keyword returns nothing, the actor still writes one diagnostic record so a query is never silently dropped.
5. Everything lands in your dataset, exportable as JSON, CSV, or Excel.

You don't need to manage any browsers or scrapers. For larger runs, use a residential proxy.

**A note on "price index":** it's a snapshot of what sellers are asking right now, not a certified appraisal and not a record of what watches actually sold for. Run it again later (an Apify schedule works well) to see how the asking-price range moves over time.

### Input

```json
{
    "mode": "price-index",
    "query": "Rolex Submariner",
    "maxItems": 60,
    "currency": "USD",
    "maxConcurrency": 4,
    "maxRequestRetries": 5,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

| Field | Type | Description |
| --- | --- | --- |
| `mode` | string | **Required.** `"price-index"` (default) — asking-price snapshot. `"dealer-search"` — dealer leads currently selling that watch. |
| `query` | string | **Required.** A watch brand, model, or reference number, e.g. `Rolex Submariner` or `Rolex Submariner 116610LN`. Chrono24 only supports searching by watch keyword, not by dealer name — `dealer-search` finds the dealers selling matching watches, it can't look up a dealer by name directly. |
| `maxItems` | integer | How many search-result listings to pull (~60/page), `1`–`240`. In `price-index` mode this is the sample size. In `dealer-search` mode it's the scan budget — the final unique-dealer count is usually smaller since several listings often belong to the same dealer. Default `60`. |
| `currency` | string | Currency every price is shown in: `USD`, `EUR`, `GBP`, `CHF`, `JPY`, `AUD`, or `CAD`. Default `USD`. |
| `maxConcurrency` | integer | Parallel requests across search pages, watch pages, and dealer profile pages (`1`–`20`). Default `4`. |
| `maxRequestRetries` | integer | Retries per page before giving up (`1`–`15`). Default `5`. |
| `proxyConfiguration` | object | Apify Proxy or a custom proxy list. A residential proxy is recommended for larger, deeper runs. |

### Output

#### Price index mode (`mode: "price-index"`)

One `WATCH_LISTING` record per watch:

```json
{
    "recordType": "WATCH_LISTING",
    "query": "Rolex Submariner 116610LN",
    "page": 1,
    "title": "Rolex Submariner Date",
    "subtitle": "116610LN",
    "listingId": "36274032",
    "detailUrl": "https://www.chrono24.com/rolex/submariner-date--id36274032.htm",
    "priceText": "$9,800",
    "price": 9800,
    "currency": "USD",
    "city": null,
    "country": "United States of America",
    "sellerType": "Private Seller",
    "badges": ["Private Seller", "Popular"],
    "image": "https://img.chrono24.com/images/uhren/36274032-azv1bbbez4wn1a61u4igbj0j-Square300.jpg",
    "scrapedAt": "2026-08-06T10:00:01Z"
}
```

Plus one `PRICE_INDEX` summary record for the whole run — real output from a live run of `"Rolex Submariner 116610LN"` (40 listings):

```json
{
    "recordType": "PRICE_INDEX",
    "query": "Rolex Submariner 116610LN",
    "sampleSize": 40,
    "pricedListings": 40,
    "currency": "USD",
    "priceMin": 9800,
    "priceMax": 18389,
    "priceMedian": 12474.5,
    "priceAvg": 12675.12,
    "dealerListings": 30,
    "privateSellerListings": 10,
    "dealerSharePct": 75,
    "note": "Snapshot computed from live asking-price listings scraped just now — not a certified valuation and not a record of actual sale prices. Re-run this actor over time (e.g. on an Apify schedule) to build a price trend for a model/reference.",
    "scrapedAt": "2026-08-06T10:00:01Z"
}
```

| Field | Type | Description |
| --- | --- | --- |
| `recordType` | string | `"WATCH_LISTING"` for each watch, `"PRICE_INDEX"` for the summary. |
| `title` / `subtitle` | string | Watch name and reference/variant line. |
| `listingId` / `detailUrl` | string | Chrono24 listing ID and its full detail page URL. |
| `priceText` / `price` / `currency` | string / number / string | Asking price as shown, its numeric value, and ISO currency. |
| `city` / `country` | string | Seller's location. `city` is only published for some listings. |
| `sellerType` | string | `"Dealer"`, `"Private Seller"`, or `"Trusted Seller"`. |
| `badges` | array | Marketing/seller pills shown on the card. |
| `sampleSize` / `pricedListings` | integer | Listings scanned vs. how many carried a parseable price. |
| `priceMin` / `priceMax` / `priceMedian` / `priceAvg` | number | Price-index stats over `pricedListings`. |
| `dealerListings` / `privateSellerListings` / `dealerSharePct` | integer / integer / number | Seller-type breakdown of the sample. |
| `note` | string | Honesty disclaimer — see "A note on price index" above. |
| `error` | string | Only on diagnostic records: `NO_RESULTS` or `BLOCKED_AFTER_RETRIES`. |

#### Dealer search mode (`mode: "dealer-search"`)

One `DEALER_LEAD` record per unique dealer — real output from a live run of `"Omega Speedmaster"`:

```json
{
    "recordType": "DEALER_LEAD",
    "query": "Omega Speedmaster",
    "dealerName": "JZL Enterprises",
    "dealerSlug": "jzl_enterprises",
    "dealerProfileUrl": "https://www.chrono24.com/dealer/jzl_enterprises/index.htm",
    "verifiedDealer": true,
    "sellerTypeText": "Professional dealer",
    "memberSince": "2020",
    "rating": 4.9,
    "reviewCount": 1666,
    "badges": ["Trusted Seller", "Fast Shipper", "Punctuality", "Sales", "Response Time"],
    "salesLast90Days": 199,
    "watchesSold": 2443,
    "activeListings": 750,
    "activeListingsUrl": "https://www.chrono24.com/search/index.htm?customerId=25955&dosearch=true",
    "city": "Birmingham",
    "country": "United States of America",
    "addressText": "Birmingham, MI United States of America",
    "phone": "2482661113",
    "mobile": "2482661113",
    "storeDescription": "JZL Enterprises THE CONTACTSCall or Text: (947) 217-2807Email: Info@birminghamluxurywatches.com...",
    "sampleListingTitle": "Omega Speedmaster Professional Moonwatch",
    "sampleListingUrl": "https://www.chrono24.com/omega/speedmaster-professional-steel-cal-861-mens-watch-145022---for-parts--id47661219.htm",
    "sampleListingPrice": 3395,
    "sampleListingCurrency": "USD",
    "scrapedAt": "2026-08-06T10:09:46Z"
}
```

| Field | Type | Description |
| --- | --- | --- |
| `dealerName` | string | Dealer's registered/display name. |
| `dealerSlug` / `dealerProfileUrl` | string | Chrono24 dealer profile identifier and URL. |
| `verifiedDealer` | boolean | `true` if the dealer carries Chrono24's "Trusted Seller" badge (its own strict verification for dealers). |
| `sellerTypeText` | string | e.g. `"Professional dealer"`. |
| `memberSince` | string | Year the dealer joined Chrono24. |
| `rating` / `reviewCount` | number / integer | Dealer's star rating and number of buyer reviews. |
| `badges` | array | Chrono24 performance badges (Trusted Seller, Fast Shipper, Punctuality, Response Time, Sales). |
| `salesLast90Days` | integer | Items sold in the last 90 days, when Chrono24 publishes it. |
| `watchesSold` / `activeListings` / `activeListingsUrl` | integer / integer / string | Lifetime watches sold, current active listing count, and a link to browse them all. |
| `city` / `country` | string | Dealer's location. |
| `addressText` | string | Fuller address from the dealer's legal/imprint details, when published (sometimes street-level, sometimes city-level only). |
| `phone` / `fax` / `mobile` | string | Contact numbers from the dealer's profile page, when the dealer publishes them. Chrono24 does not expose these for every dealer, and never for private sellers — buyers otherwise message sellers through the platform. |
| `languagesSpoken` | array | Languages the dealer lists as spoken, when shown. |
| `hasPhysicalStore` | boolean | `true` if Chrono24 marks the dealer as having a walk-in store. |
| `storeDescription` | string | The dealer's free-text "About us" blurb, when published (often repeats the phone/email for convenience). |
| `sampleListingTitle` / `sampleListingUrl` / `sampleListingPrice` / `sampleListingCurrency` | string / string / number / string | One of this dealer's listings that matched your query, for context. |
| `error` | string | Only on diagnostic records: `NO_RESULTS`, `NO_DEALER_LISTINGS` (matches existed but were all private sellers), or `BLOCKED_AFTER_RETRIES`. |

### Other Watch / Marketplace Scrapers

| Actor | Description |
| --- | --- |
| [Chrono24 Search Scraper](https://apify.com/chrono24-search-scraper) | Keyword search → watch listings with price, currency, seller, and optional full detail. |
| [Chrono24 Product Scraper](https://apify.com/chrono24-product-scraper) | Full watch detail page: spec table, seller card, images, and description. |
| [Chrono24 Market Intel](https://apify.com/chrono24-market-intel) | Verified-dealer leads with contact info, plus a live asking-price index for any watch model or reference. |
| [eBay Search Scraper](https://apify.com/ebay-search-scraper) | Keyword search across eBay listings with price, condition, and seller. |
| [eBay Sold Comps Scraper](https://apify.com/ebay-sold-comps-scraper) | Sold-listing comparables for price history and resale research. |

# Actor input Schema

## `mode` (type: `string`):

'price-index' returns real asking prices for the query plus a median/min/max/avg summary. 'dealer-search' returns contact/profile info for the dealers currently listing that watch.

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

A watch brand, model, or reference number to search on Chrono24, e.g. 'Rolex Submariner' or 'Rolex Submariner 116610LN'. Chrono24 only supports searching by watch keyword, not by dealer name — 'dealer-search' mode finds the dealers currently selling watches that match this keyword.

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

How many search-result listings to pull for the query (about 60 per page). In 'price-index' mode this is your sample size. In 'dealer-search' mode it's the scan budget — each dealer-listed watch in the scan is checked, then deduplicated down to unique dealers, so the final lead count is usually smaller than this number.

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

Currency Chrono24 converts every listing price into, so the price index is computed on a consistent basis.

## `maxConcurrency` (type: `integer`):

Maximum number of parallel requests (search pages, watch detail pages, and dealer profile pages).

## `maxRequestRetries` (type: `integer`):

How many times a page request will be retried before giving up on that page.

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

Apify Proxy or your own proxy list. A residential proxy is recommended for larger runs that go several pages deep.

## Actor input object example

```json
{
  "mode": "price-index",
  "query": "Rolex Submariner",
  "maxItems": 60,
  "currency": "USD",
  "maxConcurrency": 4,
  "maxRequestRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `recordType` (type: `string`):

Which kind of row this is.

## `page` (type: `string`):

Page as reported by the source.

## `title` (type: `string`):

Title of the item.

## `subtitle` (type: `string`):

Subtitle as reported by the source.

## `listingId` (type: `string`):

Listing Id as reported by the source.

## `detailUrl` (type: `string`):

Link to the detail.

## `priceText` (type: `string`):

Price Text as reported by the source.

## `price` (type: `string`):

Price of the item. Numeric value.

## `city` (type: `string`):

City.

## `country` (type: `string`):

Country.

## `sellerType` (type: `string`):

Seller Type as reported by the source.

## `badges` (type: `string`):

Badges.

## `image` (type: `string`):

Image URL.

## `scrapedAt` (type: `string`):

Scraped At as reported by the source.

## `sampleSize` (type: `string`):

Sample Size as reported by the source.

## `pricedListings` (type: `string`):

Priced Listings.

## `priceMin` (type: `string`):

Price Min as reported by the source.

## `priceMax` (type: `string`):

Price Max as reported by the source.

## `priceMedian` (type: `string`):

Price Median as reported by the source.

## `priceAvg` (type: `string`):

Price Avg as reported by the source.

## `dealerListings` (type: `string`):

Dealer Listings.

## `privateSellerListings` (type: `string`):

Private Seller Listings.

## `dealerSharePct` (type: `string`):

Dealer Share Pct as reported by the source.

## `note` (type: `string`):

Free-text note from the source.

## `dealerName` (type: `string`):

Dealer Name as reported by the source.

## `dealerSlug` (type: `string`):

Dealer Slug as reported by the source.

## `dealerProfileUrl` (type: `string`):

Link to the dealer profile.

## `verifiedDealer` (type: `string`):

Verified Dealer as reported by the source.

## `sellerTypeText` (type: `string`):

Seller Type Text as reported by the source.

## `memberSince` (type: `string`):

Member Since as reported by the source.

## `rating` (type: `string`):

Rating score. Numeric value.

## `reviewCount` (type: `string`):

Number of reviews. Whole number.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "Rolex Submariner",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/chrono24-market-intel").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "query": "Rolex Submariner",
    "proxyConfiguration": { "useApifyProxy": True },
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "Rolex Submariner",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call xtracto/chrono24-market-intel --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xtracto/chrono24-market-intel"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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