# ⌚ Chrono24 Luxury Watch Arbitrage & Deal Finder (`automation_studio/chrono24-watch-arbitrage-finder`) Actor

Scans Chrono24 luxury watch listings, calculates real-time reference-level market benchmarks, detects genuine below-market arbitrage deals, and dispatches instant webhook notifications.

- **URL**: https://apify.com/automation\_studio/chrono24-watch-arbitrage-finder.md
- **Developed by:** [Automation Studio](https://apify.com/automation_studio) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 verified intelligence record leads

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

## ⌚ Chrono24 Luxury Watch Arbitrage & Deal Finder

Discover genuine **below-market luxury watch arbitrage deals** on Chrono24 with real-time reference-level market benchmarking, outlier filtering, and instant Discord / Slack webhook alerts.

***

### 💎 Why Chrono24 Watch Arbitrage?

Watch flippers, grey-market dealers, and collectors routinely make **$500 to $3,000+ profit per watch flip** by purchasing underpriced watches posted by motivated private sellers or dealers who want immediate liquidity.

However, hunting for mispriced watches manually is nearly impossible:

- Profitable deals (10% to 25% below market) **sell within minutes**.
- Competitor scrapers just dump 5,000 raw listings into Excel with zero valuation metrics.
- Raw scrapers regularly get fooled by **$400 empty boxes, extra links, or damaged parts** listed under luxury reference numbers.

The **Chrono24 Luxury Watch Arbitrage & Deal Finder** solves this by normalizing reference models, computing the unpolluted **Median Market Benchmark**, calculating the exact **Discount % / Profit Spread**, and alerting you the moment a high-spread opportunity is listed.

***

### ⚡ Core Features

- 📊 **Reference-Level Market Benchmarking**: Dynamically calculates the trimmed median price across active listings for the target reference model.
- 💰 **Exact Profit Spread Calculation**: Computes `discountPercent` and `dollarSavings` for every listing so you instantly know your flip margin.
- 🚫 **Zero-False-Positive Parts Filter**: Automatically strips empty presentation boxes, dials, bezels, straps, and movement parts from distorting your benchmarks.
- 🛡️ **Dealer Badge Verification**: Filters for Chrono24 Professional Dealers with Buyer Protection to eliminate unrated/suspicious private accounts.
- 📦 **Scope of Delivery Filtering**: Easily isolate Full Sets (Original Box & Original Papers) vs Watch Only.
- 🎯 **Enriched Market Rank (No Empty Datasets)**: In `dealsOnly: false` mode, you get 100% of listings ranked by discount percentage plus a top-level **Market Summary Card**, ensuring you always have market floor visibility even if strict thresholds aren't hit today.
- 🔔 **Instant Discord & Slack Alerts**: Sends rich notification cards with profit spread, seller trust rating, and a 1-click buy button.
- 🧠 **Stateful Deduplication**: Remembers previously alerted watches in Key-Value storage so recurring scheduled runs only notify you about brand-new opportunities.

***

### 📥 Input Parameters

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `query` | `string` | `"Rolex Submariner 126610LN"` | Brand, model, or reference number to scan and benchmark. |
| `minDiscountPercent` | `integer` | `10` | Minimum discount percentage below market value to flag as an arbitrage deal. |
| `dealsOnly` | `boolean` | `false` | `false` = return all listings ranked by discount; `true` = only return qualifying deals. |
| `dealersOnly` | `boolean` | `false` | When `true`, only includes verified Professional Dealers with Buyer Protection. |
| `excludeAccessories` | `boolean` | `true` | Automatically excludes parts, dials, links, and empty boxes. |
| `minPriceUsd` | `integer` | `500` | Minimum price sanity floor to filter out stray accessories. |
| `scopeOfDelivery` | `string` | `"any"` | Filter for Full Sets (`box_and_papers`), Box Only, Papers Only, or Any. |
| `maxListings` | `integer` | `60` | Maximum listings to analyze per run. |
| `webhookUrl` | `string` | `""` | Optional Discord or Slack webhook URL for instant deal cards. |
| `webhookDealsOnly` | `boolean` | `true` | Only dispatch webhooks when listings meet or exceed `minDiscountPercent`. |
| `proxyConfiguration` | `object` | `{"useApifyProxy": true}` | Apify Proxy configuration (Auto or Residential). |

***

### 📤 Output Dataset Format

Each record pushed to the default dataset includes comprehensive pricing and valuation data:

```json
{
  "id": "32322343",
  "title": "Rolex Submariner Date 41mm 126610LN",
  "brand": "Rolex",
  "model": "Submariner Date",
  "referenceNumber": "126610LN",
  "askingPrice": 12150.0,
  "currency": "USD",
  "shippingPrice": 120.0,
  "marketBenchmark": 14200.0,
  "discountPercent": 14.4,
  "dollarSavings": 2050.0,
  "dealRating": "🎯 GOOD VALUE (10-14% below market)",
  "isArbitrageDeal": true,
  "condition": "Very Good",
  "scopeOfDelivery": "Original Box & Original Papers (Full Set)",
  "year": "2022",
  "sellerName": "Swiss Timepieces Direct",
  "sellerType": "Professional Dealer",
  "sellerCountry": "United States (Miami, FL)",
  "isVerifiedDealer": true,
  "listingUrl": "https://www.chrono24.com/rolex/submariner-date--id32322343.htm",
  "imageUrl": "https://cdn2.chrono24.com/images/uhren/32322343-ExtraLarge.jpg",
  "discoveredAt": "2026-09-22T00:50:00.000Z"
}
```

***

### 💰 Pricing & Monetization

Configured with Apify's **Pay-Per-Event (`PAY_PER_EVENT`)** model at competitive market parity:

- **Actor Start**: **$0.002** (one-time base run overhead)
- **Delivered Dataset Item**: **$0.0025** per analyzed listing with full valuation benchmarks, discount spread, and scam checks.

***

### 🛡️ Best Practices for Watch Flippers

1. **Schedule 15-Minute Runs**: High-demand models (Submariners, GMT-Masters, Royal Oaks) priced 15%+ below market sell quickly. Schedule the actor to run every 15–30 minutes with a Discord webhook enabled.
2. **Use Full Sets for Faster Resale**: Filter `scopeOfDelivery: "box_and_papers"` for the highest liquidity and easiest secondary-market resale.
3. **Turn on Verified Dealers**: For international purchases, enable `dealersOnly: true` to ensure all transactions are protected by Chrono24's Escrow Service.

# Actor input Schema

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

Search by brand, model, or reference number (e.g., 'Rolex Submariner 126610LN', 'Omega Speedmaster 310.30.42.50.01.001', 'Cartier Santos WSSA0029', 'Audemars Piguet Royal Oak').

## `minDiscountPercent` (type: `integer`):

Minimum percentage below median market value to flag as an arbitrage deal. Pro Tip: For modern Rolex/Patek, market spreads are tight (set 5%–7% to catch $1,000+ profit flips). For Omega, Cartier, Breitling, or vintage models, set 10%–15%.

## `dealsOnly` (type: `boolean`):

If FALSE (Recommended), returns all matching listings ranked by discount % with market benchmarks and deal ratings. If TRUE, strictly returns only listings meeting your min discount %.

## `dealersOnly` (type: `boolean`):

Filter for listings from Chrono24 Professional Dealers with Buyer Protection. Helps eliminate unrated or suspicious private sellers.

## `excludeAccessories` (type: `boolean`):

Automatically filters out dials, bezels, straps, extra links, empty watch boxes, and movement parts to prevent false deals.

## `minPriceUsd` (type: `integer`):

Ignore any listing priced below this amount to filter out accessories or parts that bypass keyword filters.

## `scopeOfDelivery` (type: `string`):

Filter by package completeness. Full sets (box and papers) command higher resale liquidity.

## `maxListings` (type: `integer`):

Maximum number of listings to analyze and benchmark.

## `webhookUrl` (type: `string`):

Optional Discord or Slack webhook URL to receive instant notification cards with profit spread and 1-click buy links.

## `webhookDealsOnly` (type: `boolean`):

Only dispatch webhook alert cards for listings that meet or exceed your min discount percentage.

## `includeSummaryInDataset` (type: `boolean`):

If TRUE, includes the top-level Market Benchmark Summary Card as record #1 in the dataset. If FALSE (Recommended), the dataset contains 100% pure, clean watch listing rows for pristine CSV/Excel exports, while the summary card is accessible in the Key-Value Store (OUTPUT / SUMMARY).

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

Chrono24 requires reliable proxy routing. Apify Proxy Auto or Residential is recommended.

## Actor input object example

```json
{
  "query": "Rolex Submariner 126610LN",
  "minDiscountPercent": 10,
  "dealsOnly": false,
  "dealersOnly": false,
  "excludeAccessories": true,
  "minPriceUsd": 500,
  "scopeOfDelivery": "any",
  "maxListings": 120,
  "webhookDealsOnly": true,
  "includeSummaryInDataset": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing verified luxury watch listings with discount spread, reference market benchmarks, seller verification, and 1-click buy links

## `summary` (type: `string`):

Aggregated market statistics including median benchmark price, lowest price available, highest discount found, and arbitrage deal count

# 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 126610LN"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_studio/chrono24-watch-arbitrage-finder").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 126610LN" }

# Run the Actor and wait for it to finish
run = client.actor("automation_studio/chrono24-watch-arbitrage-finder").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 126610LN"
}' |
apify call automation_studio/chrono24-watch-arbitrage-finder --silent --output-dataset

```

## MCP server setup

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

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/05ILPal9vGliwcBih/builds/61G5pWGAz0alpuulA/openapi.json