# Chrono24 Listings Scraper — Search & Detail (`bakos_bence/chrono24-listings`) Actor

Scrape Chrono24 watch listings from search, brand, and detail URLs — price, currency, brand, model, specs, images, and dealer business contact when published on the listing.

- **URL**: https://apify.com/bakos_bence/chrono24-listings.md
- **Developed by:** [Bakos Bence](https://apify.com/bakos_bence) (community)
- **Categories:** E-commerce
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.25 / 1,000 results

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

### What is Chrono24 Listings Scraper — Search & Detail?

Scrape Chrono24 watch listings from search, brand, and detail URLs — price, currency, brand, model, specs, images, and dealer business contact when published on the listing.

[Documentation](https://bakosbence.com/web-data-collection/chrono24-listings/)

### What Chrono24 Listings Scraper — Search & Detail returns

| Field | What it is | Example |
| --- | --- | --- |
| `listingId` | Listing ID | 47341084 |
| `brand` | Brand | Rolex |
| `model` | Model | Submariner Date 116610LN |
| `title` | Title | Rolex Submariner Date 116610LN |
| `price` | Price | 11495.0 |
| `currency` | Currency | USD |
| `listingUrl` | URL | https://www.chrono24.com/rolex/submariner-date-116610ln--id47341084.htm |

### How do I scrape Chrono24 watch listings from search, brand, and detail URLs?

1. Click **Try for free**.
2. Fill **Chrono24 links**, **Open each listing for full specs** and **Search pages per URL**.
3. Click **Start**.
4. Open the dataset and download it, or send it on with one of the integrations below.

Saved runs on the **Tasks** tab:

- [Patek Nautilus Chrono24 listings and asking prices](https://console.apify.com/actors/tasks/bakos_bence/scrape-patek-nautilus-chrono24-listings)
- [Rolex Chrono24 asking prices for grey-market comps](https://console.apify.com/actors/tasks/bakos_bence/monitor-rolex-chrono24-asking-prices)
- [Rolex Daytona Chrono24 listings and asking prices](https://console.apify.com/actors/tasks/bakos_bence/scrape-rolex-daytona-chrono24-listings)

### Input

The **Input** tab lists every field. The sample input is:

```json
{
    "startUrls": [
        "https://www.chrono24.com/search/index.htm?query=Rolex&dosearch=true"
    ],
    "fetchListingDetails": false,
    "maxIndexPages": 1,
    "flatten": true,
    "includeRaw": false,
    "maxItems": 5,
    "maxRequestRetries": 2
}
```

### Output

One row looks like this. `scrapedAt`, when present, is the time that run finished.

```json
{
  "rowType": "card",
  "listingId": "47341084",
  "listingUrl": "https://www.chrono24.com/rolex/submariner-date-116610ln--id47341084.htm",
  "title": "Rolex Submariner Date 116610LN",
  "brand": "Rolex",
  "model": "Submariner Date 116610LN",
  "price": 11495.0,
  "currency": "USD"
}
```

### How much does Chrono24 Listings Scraper — Search & Detail cost?

You pay for each row saved. Platform usage is included. Current rates are on the [Pricing](https://apify.com/bakos_bence/chrono24-listings/pricing) tab.

How pay-per-event billing works: [Actors in Store](https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event).

### Related Actors

| Actor | When to use it |
| --- | --- |
| [Watchfinder Listings Scraper](https://apify.com/bakos_bence/watchfinder-listings) | You add **UK dealer** pre-owned stock next to Chrono24 marketplace comps |
| [Shopify Products Scraper](https://apify.com/bakos_bence/shopify-products-scraper) | You run **multi-source retail** price monitoring (boutiques + watches) |
| [eMAG Product Scraper](https://apify.com/bakos_bence/emag-products) | You also scrape **CEE ecommerce** listings alongside luxury watches |

### Integrations

#### Excel

1. Click **Try for free**, run this Actor, and wait until the run finishes.
2. Open that run and go to its dataset.
3. Choose **Export**, then **Excel**.

To download the newest successful run later without opening the dataset:

1. In Apify Console, open **Settings → API & Integrations** and copy an API token.
2. On this Actor, open the **Tasks** tab, open the task you want, and copy the task ID from the URL.
3. Run that task once.
4. Paste this into a browser. Replace `TASK_ID` and `YOUR_TOKEN`.

```text
https://api.apify.com/v2/actor-tasks/TASK_ID/runs/last/dataset/items?format=xlsx&clean=true&status=SUCCEEDED&token=YOUR_TOKEN
```

Anyone with that URL can read the rows. Treat the token like a password.

Dataset export formats: [Dataset items](https://docs.apify.com/api/v2/dataset-items-get).

#### Google Sheets

1. In Apify Console, open **Settings → API & Integrations** and copy an API token.
2. On this Actor, open the **Tasks** tab, open the task you want, and copy the task ID from the URL.
3. Run that task once so there is a successful dataset.
4. In a Google Sheet, click cell **A1** and paste this formula. Replace `TASK_ID` and `YOUR_TOKEN`.

```text
=IMPORTDATA("https://api.apify.com/v2/actor-tasks/TASK_ID/runs/last/dataset/items?format=csv&clean=true&status=SUCCEEDED&token=YOUR_TOKEN")
```

5. Wait until the columns fill. Sheets refreshes `IMPORTDATA` on its own. Use **Data → Data connectors → Refresh** when you want it now.

Anyone with that URL can read the rows. Treat the token like a password.

#### API, Python, and Node

1. In Apify Console, open **Settings → API & Integrations** and copy an API token.
2. Send this request. Replace `YOUR_TOKEN`.

```bash
curl -X POST "https://api.apify.com/v2/acts/bakos_bence~chrono24-listings/runs?token=YOUR_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":["https://www.chrono24.com/search/index.htm?query=Rolex&dosearch=true"],"fetchListingDetails":false,"maxIndexPages":1,"flatten":true,"includeRaw":false,"maxItems":5,"maxRequestRetries":2}'
```

3. From the response, copy `defaultDatasetId`.
4. Fetch the rows:

```text
https://api.apify.com/v2/datasets/DATASET_ID/items?format=json&clean=true&token=YOUR_TOKEN
```

The **API** tab on this page has the same call in JavaScript, Python, and the CLI. Client docs: [JavaScript](https://docs.apify.com/api/client/js), [Python](https://docs.apify.com/api/client/python/docs/quick-start), [Run an Actor](https://docs.apify.com/api/v2/act-runs-post).

#### Zapier

1. In Apify Console, open **Settings → API & Integrations** and copy an API token. You will only need it if the connection asks for a token. The usual path is the access prompt below.
2. In Zapier, create a Zap. For the action, search **Apify** and choose **Run Actor**.
3. Connect your Apify account and choose **Allow Access**.
4. Select **Chrono24 Listings Scraper — Search & Detail**.
5. Paste this input:

```json
{
    "startUrls": [
        "https://www.chrono24.com/search/index.htm?query=Rolex&dosearch=true"
    ],
    "fetchListingDetails": false,
    "maxIndexPages": 1,
    "flatten": true,
    "includeRaw": false,
    "maxItems": 5,
    "maxRequestRetries": 2
}
```

6. Use a synchronous run only when the run will finish within 30 seconds. Otherwise leave it asynchronous, then add **Fetch dataset items**, or start the Zap with the **Finished Actor run** trigger.
7. Test the step. Add the next action, such as Google Sheets, Slack, or email. Publish the Zap.

Triggers and the other actions: [Zapier integration](https://docs.apify.com/integrations/zapier).

#### Make

1. In Apify Console, open **Settings → API & Integrations** and copy an API token.
2. In a Make scenario, add a module and search **Apify**.
3. Create the connection with OAuth, or paste the API token.
4. Choose **Run an Actor**. Select **Chrono24 Listings Scraper — Search & Detail**. Set **Run synchronously** to **Yes**.
5. Paste this input:

```json
{
    "startUrls": [
        "https://www.chrono24.com/search/index.htm?query=Rolex&dosearch=true"
    ],
    "fetchListingDetails": false,
    "maxIndexPages": 1,
    "flatten": true,
    "includeRaw": false,
    "maxItems": 5,
    "maxRequestRetries": 2
}
```

6. Add **Get Dataset Items**. Set the dataset ID to the default dataset ID from the Run an Actor module.
7. Add the module that should receive the rows, such as Google Sheets **Bulk add rows**, and map the fields.

If the run can take longer than your Make plan lets a synchronous module wait, start with **Watch Actor Runs** instead, then add **Get Dataset Items**. Details: [Make integration](https://docs.apify.com/integrations/make).

#### n8n

1. In Apify Console, open **Settings → API & Integrations** and copy an API token.
2. On n8n Cloud, open the nodes panel, search **Apify**, and install the node. On a self-hosted n8n, go to **Settings → Community Nodes → Install** and enter `@apify/n8n-nodes-apify`.
3. Create a credential. Search **Apify API**, paste the token, and save. On n8n Cloud you can use **Apify OAuth2** instead.
4. Add an Apify node. Choose **Run Actor**. Pick **Chrono24 Listings Scraper — Search & Detail**. Turn on **Wait for finish**.
5. Set the input to:

```json
{
    "startUrls": [
        "https://www.chrono24.com/search/index.htm?query=Rolex&dosearch=true"
    ],
    "fetchListingDetails": false,
    "maxIndexPages": 1,
    "flatten": true,
    "includeRaw": false,
    "maxItems": 5,
    "maxRequestRetries": 2
}
```

6. Add another Apify node, **Get Dataset Items**. Set the dataset ID to the `defaultDatasetId` from the Run Actor node.
7. Add the next node, such as Google Sheets, and map the fields.

Full setup, triggers, and the AI-tool node: [n8n integration](https://docs.apify.com/integrations/n8n).

#### Power BI

1. In Apify Console, open **Settings → API & Integrations** and copy an API token.
2. On this Actor, open the **Tasks** tab, open the task you want, and copy the task ID from the URL.
3. Run that task once.
4. Open Power BI Desktop → **Home** → **Get data** → **Web**.
5. Paste this URL. Replace `TASK_ID` and `YOUR_TOKEN`.

```text
https://api.apify.com/v2/actor-tasks/TASK_ID/runs/last/dataset/items?format=csv&clean=true&status=SUCCEEDED&token=YOUR_TOKEN
```

6. When asked how to sign in, choose **Anonymous** → **Connect**.
7. Check that the preview is a table, then **Load**.
8. After you publish, schedule refresh against that same URL.

A `401` means the token is missing or you did not choose **Anonymous**. Anyone with the URL can read the rows.

#### Looker Studio

Looker Studio does not open a private CSV URL on its own. Put the rows in a Google Sheet first.

1. In Apify Console, open **Settings → API & Integrations** and copy an API token.
2. On this Actor, open the **Tasks** tab, open the task you want, and copy the task ID from the URL.
3. Run that task once.
4. In a Google Sheet, click cell **A1** and paste this formula. Replace `TASK_ID` and `YOUR_TOKEN`.

```text
=IMPORTDATA("https://api.apify.com/v2/actor-tasks/TASK_ID/runs/last/dataset/items?format=csv&clean=true&status=SUCCEEDED&token=YOUR_TOKEN")
```

5. Wait until the columns fill.
6. In Looker Studio, choose **Create → Report → Google Sheets** and pick that spreadsheet.
7. After the next run, refresh the Sheet, then refresh the Looker data source.

For a single snapshot, open the finished run, export **CSV** from the dataset, and use **File upload** in Looker Studio.

#### Tableau

1. In Apify Console, open **Settings → API & Integrations** and copy an API token.
2. On this Actor, open the **Tasks** tab, open the task you want, and copy the task ID from the URL.
3. Run that task once.
4. In Tableau Desktop **2023.3+**, install the **REST API** connector from Tableau Exchange.
5. Choose **Connect → To a Server → REST API**.
6. Paste this URL. Replace `TASK_ID` and `YOUR_TOKEN`. Set the response format to **CSV**.

```text
https://api.apify.com/v2/actor-tasks/TASK_ID/runs/last/dataset/items?format=csv&clean=true&status=SUCCEEDED&token=YOUR_TOKEN
```

7. Leave credentials empty. The token is already in the URL.
8. Create an extract. Refresh it after the next run.

For a single snapshot, open the finished run, export **CSV** from the dataset, and connect Tableau to that file.

#### Qlik

1. In Apify Console, open **Settings → API & Integrations** and copy an API token.
2. On this Actor, open the **Tasks** tab, open the task you want, and copy the task ID from the URL.
3. Run that task once.
4. In Qlik Cloud or Qlik Sense, choose **Add data → REST**.
5. Set the method to **GET** and paste this URL. Replace `TASK_ID` and `YOUR_TOKEN`.

```text
https://api.apify.com/v2/actor-tasks/TASK_ID/runs/last/dataset/items?format=csv&clean=true&status=SUCCEEDED&token=YOUR_TOKEN
```

6. Set the response type to **CSV**.
7. Test the connection, pick the table, and load.
8. Reload the app after the next run.

For a single snapshot, open the finished run, export **CSV** from the dataset, and add that file in Qlik.

#### Webhooks

1. In Apify Console, open this Actor and go to **Integrations**.
2. Add a webhook for **Actor run succeeded**.
3. Set the URL of the service that should receive the run.
4. When a run finishes, the payload includes `defaultDatasetId`. Read the rows with this URL. Replace `DATASET_ID` and `YOUR_TOKEN`. The token is under **Settings → API & Integrations**.

```text
https://api.apify.com/v2/datasets/DATASET_ID/items?format=json&clean=true&token=YOUR_TOKEN
```

Event types and the payload: [Webhooks](https://docs.apify.com/integrations/webhooks).

#### AI tools

1. Open the **API** tab on this Actor.
2. Copy the MCP config shown there.
3. Paste it into the MCP client (Claude, Cursor, or another client that accepts that config).
4. Sign in when the client asks. It can then run this Actor.

Setup for each client: [Apify MCP server](https://docs.apify.com/integrations/mcp).

Airtable, Google Drive, Slack, and Snowflake are listed in [Integrations](https://docs.apify.com/platform/integrations).

### FAQ

#### What data can you extract from Chrono24?

Public listing facts such as listing id, title, brand, model, price, currency, condition, year, location, images, structured spec fields, and dealer business contact when published.

#### How to scrape Chrono24 listings

1. Open the Actor in Apify Console.
2. Use **Chrono24 links** (prefill or paste from the site).
3. Adjust filters and **Maximum listings** / **Search pages per URL**; enable full specs only if you need detail columns.
4. Run and export JSON/CSV from the Dataset tab.

#### Can I schedule this?

Yes. Save a Task from the input you want, then add a schedule in Console. After each successful run, this URL returns that task’s newest dataset. Replace `TASK_ID` and `YOUR_TOKEN` (the token is under **Settings → API & Integrations**).

```text
https://api.apify.com/v2/actor-tasks/TASK_ID/runs/last/dataset/items?format=json&clean=true&status=SUCCEEDED&token=YOUR_TOKEN
```

This Actor is unofficial.

# Actor input Schema

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

One URL per line: site search, brand index (<code>/rolex/index.htm</code>), model page (<code>/rolex/daytona--mod2.htm</code>), or a single listing. Pick a suggestion or paste your own from Chrono24. Examples: https://www.chrono24.com/search/index.htm?query=Rolex\&dosearch=true, https://www.chrono24.com/rolex/index.htm, https://www.chrono24.com/rolex/daytona--mod2.htm, https://www.chrono24.com/omega/index.htm, https://www.chrono24.com/search/index.htm?query=patek+nautilus\&dosearch=true, https://www.chrono24.com/patekphilippe/nautilus--mod106.htm, https://www.chrono24.com/search/index.htm?query=audemars+piguet+royal+oak\&dosearch=true, https://www.chrono24.com/cartier/index.htm, https://www.chrono24.com/tudor/index.htm, https://www.chrono24.com/search/index.htm?query=116610LN\&dosearch=true.

## `searchParams` (type: `object`):

Optional JSON merged into search URLs — use Chrono24’s own param names/values from a filtered URL in your browser (e.g. <code>priceFrom</code>, <code>sortorder</code>). Sidebar labels like condition or movement are <b>not</b> mapped for you.

## `fetchListingDetails` (type: `boolean`):

Off = fast search cards (price, brand, model, URL). On = detail page per listing (<code>specs\_\*</code>, more images, dealer contact) — costs more proxy time.

## `maxIndexPages` (type: `integer`):

How many result pages to walk for each search/brand/model URL (not used for single listing links).

## `flatten` (type: `boolean`):

On = <code>specs_caliber</code>, <code>specs_casediameter</code>, etc. as top-level columns. Off = nested objects.

## `includeRaw` (type: `boolean`):

Debugging only — adds a raw payload field on detail rows. Leave off for normal exports.

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

Hard cap on listing rows (billing scales with this). Prefill <b>5</b> for a cheap first run.

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

Not used — detail pages are fetched sequentially in this build.

## `minConcurrency` (type: `integer`):

Not used.

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

How often to retry a blocked search or detail page before skipping.

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

Managed by the Actor — Residential is required and forced in code. Leave default.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.chrono24.com/search/index.htm?query=Rolex&dosearch=true"
  ],
  "fetchListingDetails": false,
  "maxIndexPages": 1,
  "flatten": true,
  "includeRaw": false,
  "maxItems": 5,
  "maxConcurrency": 6,
  "minConcurrency": 1,
  "maxRequestRetries": 2,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Default dataset items.

# 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": [
        "https://www.chrono24.com/search/index.htm?query=Rolex&dosearch=true"
    ],
    "fetchListingDetails": false,
    "maxIndexPages": 1,
    "maxItems": 5,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bakos_bence/chrono24-listings").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": ["https://www.chrono24.com/search/index.htm?query=Rolex&dosearch=true"],
    "fetchListingDetails": False,
    "maxIndexPages": 1,
    "maxItems": 5,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("bakos_bence/chrono24-listings").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 '{
  "startUrls": [
    "https://www.chrono24.com/search/index.htm?query=Rolex&dosearch=true"
  ],
  "fetchListingDetails": false,
  "maxIndexPages": 1,
  "maxItems": 5,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bakos_bence/chrono24-listings --silent --output-dataset

```

## MCP server setup

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

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/GfHOFp2rntEGbppCR/builds/JIIf150CARtH7Bk1S/openapi.json