# Search the Watch Market (`search_the_watch_market/watch-market-data`) Actor

Watch asking prices and new dealer listings for watches from 537,000+ live ads, 122,000+ vendors, and 160+ million price points (data since 1988). Resolve a watch model, then fetch specs, the latest snapshot, 13-week history, and new listings. Use Standby for HTTP or Start to save JSON.

- **URL**: https://apify.com/search\_the\_watch\_market/watch-market-data.md
- **Developed by:** [Search the Watch Market](https://apify.com/search_the_watch_market) (community)
- **Categories:** E-commerce, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 84.5% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Search the Watch Market

Market data for **watches**: **watch asking prices**, **specs**, **weekly charts**, and **new dealer supply** — for apps, agents, and research, without scraping dealer websites.

Built on the same dataset behind Search the Watch Market:

| | |
| --- | --- |
| **537,000+** | Active listings |
| **8.2+ million** | Historic listings |
| **816,000+** | Historic auctions |
| **122,000+** | Vendors tracked |
| **160+ million** | Price points |
| **Since 1988** | Historical coverage |

This Actor exposes **live asking-price market data**. Auction results and the long historic archive sit in that same dataset; the endpoints below return model resolve, weekly snapshots, specs, 13-week charts, new listings, and listing price history.

### What you can do

- **Find the model** — type a brand and reference; get a stable `group_id`
- **See what it’s worth** — low, high, and average asking price plus market value for the latest complete week
- **Read the specs** — case size, movement, materials, and other consensus fields
- **Track the chart** — about 13 weeks of min / mean / max in major currencies
- **See new supply** — watches listed in the last 7 days, with seller, price, and URL
- **Follow one listing** — asking-price changes over time

Use **Standby** for on-demand HTTP. Use **Start** to save JSON in an Apify dataset. Scheduling, monitoring, and the Apify API work as with any other Actor.

Brand names in examples (Rolex, Omega, and similar) are data labels only — this Actor is not affiliated with those manufacturers.

All data endpoints are GET.

### Authentication

All `/data/*` endpoints require your **Apify API token**:

```http
Authorization: Bearer <APIFY_TOKEN>
```

The Console **Standby** tab injects it automatically. From code you can pass `?token=<APIFY_TOKEN>` instead of the header if you cannot set headers.

If authentication fails, the Actor returns 401 with:

```json
{
  "status": 0,
  "error": "unauthorized",
  "message": "Missing or malformed Authorization header. Expected: Bearer <APIFY_TOKEN>"
}
```

### Pricing

See this Actor’s **Pricing** tab. You pay through Apify (platform usage and any Actor events). No separate account or key is required.

Standby is billed like a normal run while instances are up, including idle time until timeout.

When a quota is exceeded, the Actor returns 429. Handle 429 with retry/backoff. Responses may include `X-RateLimit-Limit` and `X-RateLimit-Remaining`.

### Response format

Successful responses use:

```json
{
  "status": 1,
  "...": "payload"
}
```

Error responses use:

```json
{
  "status": 0,
  "error": "<error_code>",
  "message": "<description>"
}
```

Treat a response as success only when HTTP status is **200** and the JSON has `"status": 1`.

Common HTTP statuses:

- 400 invalid input
- 401 unauthorized
- 404 not found
- 429 rate limited
- 500 server error
- 503 temporarily unavailable

### Quick start

1. Sign in to Apify, or copy an API token from Apify Settings.
2. Resolve a watch query to a `group_id`.
3. Call model endpoints with that `group_id`.
4. Use `listing_id` values from listings responses for listing-history calls.

Example:

```bash
APIFY_TOKEN="YOUR_APIFY_TOKEN"
BASE_URL="https://search_the_watch_market--watch-market-data.apify.actor"

curl -s "$BASE_URL/data/resolve?q=rolex%20submariner%20126610ln" \
  -H "Authorization: Bearer $APIFY_TOKEN"
```

### Core identifiers

- `group_id`: model-level identifier used by model endpoints
- `listing_id`: listing-level identifier used by the listing history endpoint

### Endpoints overview

| Endpoint | Purpose |
| --- | --- |
| `GET /data/resolve?q={query}` | Resolve free-text watch query to `group_id` |
| `GET /data/model/{group_id}/prices` | Latest model pricing snapshot |
| `GET /data/model/{group_id}/specs` | Model specification attributes |
| `GET /data/model/{group_id}/history` | 13-week model price history |
| `GET /data/model/{group_id}/listings` | New listings in the last 7 days |
| `GET /data/listing/{listing_id}/history` | Price-change history for one listing |
| `GET /` | Health check (no auth) |

### Endpoint reference

#### 1) Resolve query

`GET /data/resolve?q={query}`

Use this first when you do not yet have a `group_id`.

Query parameters:

- `q` (required, string): e.g. `rolex submariner 126610ln`

Success example:

```json
{
  "status": 1,
  "group_id": 2341,
  "brand": "Submariner",
  "model_number": "126610LN",
  "display_name": "Submariner 126610LN"
}
```

Request example:

```bash
curl -s "https://search_the_watch_market--watch-market-data.apify.actor/data/resolve?q=rolex%20submariner%20126610ln" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

No match example (404):

```json
{
  "status": 0,
  "error": "not_found",
  "message": "No matching group found"
}
```

If you see this message, check spelling and try the manufacturer reference number instead of a colloquial name.

#### 2) Model prices

`GET /data/model/{group_id}/prices`

Returns the latest model-level pricing snapshot.

Path parameters:

- `group_id` (required, integer)

Success example:

```json
{
  "status": 1,
  "group_id": 2314,
  "currency": "USD",
  "listing_count": 47,
  "min": 6640,
  "max": 11360,
  "mean": 8600,
  "market_value": 8370
}
```

Prices use USD when that week has USD data; otherwise the first populated fallback currency is used.

Request example:

```bash
curl -s "https://search_the_watch_market--watch-market-data.apify.actor/data/model/2314/prices" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

#### 3) Model specs

`GET /data/model/{group_id}/specs`

Returns specification attributes for the model.

Path parameters:

- `group_id` (required, integer)

Success example:

```json
{
  "status": 1,
  "group_id": 2314,
  "properties": {
    "brand": "Omega",
    "model": "Speedmaster",
    "reference_number": "310.32.42.50.01.002",
    "base_caliber": "3861",
    "case_diameter": "42mm",
    "water_resistance": "50m",
    "power_reserve": "50h",
    "case_material": "Stainless Steel",
    "bracelet_material": "Stainless Steel",
    "crystal": "Sapphire",
    "functions": "Hours, Minutes, Seconds, Chronograph, Date",
    "year_introduced": "2021"
  }
}
```

Request example:

```bash
curl -s "https://search_the_watch_market--watch-market-data.apify.actor/data/model/2314/specs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

#### 4) Model history

`GET /data/model/{group_id}/history`

Returns up to 13 complete weekly points with mean, min, max, and count.

Path parameters:

- `group_id` (required, integer)

Supported currency keys in mean/min/max:

- GBP, USD, EUR, AUD, CAD, CHF, HKD, SGD, PLN, AED, JPY

Success example:

```json
{
  "status": 1,
  "group_id": 2314,
  "weeks": [
    {
      "week": "2026-02-09",
      "mean": {
        "GBP": 6210,
        "USD": 8380,
        "EUR": 7290
      },
      "min": {
        "GBP": 5600,
        "USD": 7550,
        "EUR": 6570
      },
      "max": {
        "GBP": 7100,
        "USD": 9580,
        "EUR": 8340
      },
      "count": 38
    }
  ]
}
```

Request example:

```bash
curl -s "https://search_the_watch_market--watch-market-data.apify.actor/data/model/2314/history" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

#### 5) Model listings (new in last 7 days)

`GET /data/model/{group_id}/listings?cursor={token}`

Returns a paginated listings feed.

Path parameters:

- `group_id` (required, integer)

Query parameters:

- `cursor` (optional, string): use `next_cursor` from the prior response

Listings are a rolling 7-day window, 20 items per page. Do not use numeric page offsets — new listings would shift the result set. Listing prices stay in the dealer’s local currency.

Success example:

```json
{
  "status": 1,
  "group_id": 2314,
  "page_size": 20,
  "total_count": 43,
  "next_cursor": "eyJhZGRlZF9kYXRlIjoiMjAyNi0wNS0wM1QxODo0MjowMC4wMDBaIiwibGlzdGluZ19pZCI6MTEyNjAxMzM0fQ",
  "items": [
    {
      "listing_id": 112578408,
      "url": "https://example.com/listings/omega-speedmaster-moonwatch",
      "added_date": "2026-05-04T09:14:00.000Z",
      "price": 6450,
      "currency": "GBP",
      "seller": "Example LTD"
    }
  ]
}
```

First page:

```bash
curl -s "https://search_the_watch_market--watch-market-data.apify.actor/data/model/2314/listings" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

Next page:

```bash
curl -s "https://search_the_watch_market--watch-market-data.apify.actor/data/model/2314/listings?cursor=YOUR_NEXT_CURSOR" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

Loop while `next_cursor` is present to get every new listing.

#### 6) Listing price history

`GET /data/listing/{listing_id}/history`

Returns the observed price-change timeline for one listing.

Path parameters:

- `listing_id` (required, integer)

Success example:

```json
{
  "status": 1,
  "listing_id": 112578408,
  "history": [
    { "price": 6800, "date": "2026-02-14T12:00:00.000Z" },
    { "price": 6650, "date": "2026-03-01T08:00:00.000Z" },
    { "price": 6500, "date": "2026-03-22T14:00:00.000Z" },
    { "price": 6450, "date": "2026-04-16T21:17:04.000Z" }
  ]
}
```

Request example:

```bash
curl -s "https://search_the_watch_market--watch-market-data.apify.actor/data/listing/112578408/history" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

### Health check

`GET /`

No authentication required.

```bash
curl -s "https://search_the_watch_market--watch-market-data.apify.actor/"
```

### How to use Start

Fill the input form and click **Start**:

1. Choose an **endpoint**
2. For resolve, enter **q** (for example `rolex submariner 126610ln`)
3. For prices, specs, history, or listings, enter **group\_id**
4. For listing history, enter **listing\_id**
5. For further listing pages, paste **cursor** from `next_cursor`

The JSON is stored as dataset item 0 and as key-value record `OUTPUT`. Start runs work with the usual Apify API, tasks, and schedules.

### How to integrate

1. Store your Apify API token in a secret manager.
2. Add `Authorization: Bearer <APIFY_TOKEN>` to all `/data/*` requests (or `?token=`).
3. Resolve user input to `group_id` via `/data/resolve`.
4. Use model endpoints for analytics (prices, specs, history).
5. Use the listings endpoint for recent supply monitoring.
6. Use listing history for price-change tracking.
7. Handle 429 with retry/backoff.

Standby is HTTP, so Zapier, Make, and similar tools can call it like any other REST API.

### cURL collection

```bash
APIFY_TOKEN="YOUR_APIFY_TOKEN"
BASE_URL="https://search_the_watch_market--watch-market-data.apify.actor"
GROUP_ID="2314"
LISTING_ID="112578408"

## Resolve query
curl -s "$BASE_URL/data/resolve?q=omega%20speedmaster%20310.32.42.50.01.002" \
  -H "Authorization: Bearer $APIFY_TOKEN"

## Prices
curl -s "$BASE_URL/data/model/$GROUP_ID/prices" \
  -H "Authorization: Bearer $APIFY_TOKEN"

## Specs
curl -s "$BASE_URL/data/model/$GROUP_ID/specs" \
  -H "Authorization: Bearer $APIFY_TOKEN"

## History
curl -s "$BASE_URL/data/model/$GROUP_ID/history" \
  -H "Authorization: Bearer $APIFY_TOKEN"

## Listings
curl -s "$BASE_URL/data/model/$GROUP_ID/listings" \
  -H "Authorization: Bearer $APIFY_TOKEN"

## Listing history
curl -s "$BASE_URL/data/listing/$LISTING_ID/history" \
  -H "Authorization: Bearer $APIFY_TOKEN"
```

Issues and feature requests: use this Actor’s **Issues** tab.

# Actor input Schema

## `endpoint` (type: `string`):

Which resource to return.

## `q` (type: `string`):

Brand and model text for resolve, e.g. rolex submariner 126610ln.

## `group_id` (type: `integer`):

Model group from a previous resolve (or from a listings response). Required for prices, specs, history, and listings.

## `listing_id` (type: `integer`):

Listing id from a listings response. Required for listing price history.

## `cursor` (type: `string`):

Opaque token from next\_cursor on the previous listings page. Omit for the first page.

## `path` (type: `string`):

Optional exact path, e.g. /data/model/2314/prices. When set, this is used instead of Endpoint + IDs. Only the documented routes are allowed.

## Actor input object example

```json
{
  "endpoint": "resolve",
  "q": "rolex submariner 126610ln",
  "group_id": 2314
}
```

# Actor output Schema

## `response` (type: `string`):

No description

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

No description

# 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 = {
    "q": "rolex submariner 126610ln",
    "group_id": 2314
};

// Run the Actor and wait for it to finish
const run = await client.actor("search_the_watch_market/watch-market-data").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 = {
    "q": "rolex submariner 126610ln",
    "group_id": 2314,
}

# Run the Actor and wait for it to finish
run = client.actor("search_the_watch_market/watch-market-data").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 '{
  "q": "rolex submariner 126610ln",
  "group_id": 2314
}' |
apify call search_the_watch_market/watch-market-data --silent --output-dataset

```

## MCP server setup

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

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/Jcwy7DbO0iqqHKAKE/builds/lvWytuEUgb8arfCPi/openapi.json