# Bob's Watches Scraper (`crawlerbros/bobs-watches-scraper`) Actor

Scrape Bob's Watches, America's largest pre-owned Rolex dealer and luxury watch marketplace with 500+ certified pre-owned timepieces. Browse by brand, model, or search by keyword

- **URL**: https://apify.com/crawlerbros/bobs-watches-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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/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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Bob's Watches Scraper

Extract pre-owned luxury watch listings from **Bob's Watches** — America's largest certified pre-owned Rolex dealer and luxury watch marketplace. Browse over 500+ in-stock watches by brand, search by model name, or fetch details for any specific listing.

### What You Can Scrape

- **Watch listings** with name, brand, model, reference number, price, and availability
- **Technical specs**: movement type, case material, dial color, crystal material, bezel type, box & papers
- **Market data**: asking price in USD, seller rating (4.9/5 average)
- **Supported brands**: Rolex, Omega, Patek Philippe, Audemars Piguet, TAG Heuer, Breitling, IWC, Panerai, Cartier, Jaeger-LeCoultre, Vacheron Constantin, Tudor, and more

### Output Fields

| Field | Type | Description |
|---|---|---|
| `name` | String | Full listing name |
| `brand` | String | Watch brand (Rolex, Omega, etc.) |
| `modelName` | String | Model name (Submariner, Datejust, etc.) |
| `referenceNumber` | String | Manufacturer reference number |
| `condition` | String | Used / Certified Pre-Owned / New |
| `price` | Float | Asking price |
| `currency` | String | Currency (USD) |
| `available` | Boolean | Whether in stock |
| `caseMaterial` | String | Case material (Stainless Steel, Gold, etc.) |
| `movementType` | String | Automatic / Manual / Quartz |
| `dialColor` | String | Dial color |
| `yearRange` | String | Production year range |
| `gender` | String | Mens / Ladies |
| `crystalMaterial` | String | Sapphire / Hesalite / etc. |
| `boxAndPapers` | String | Box Only / Box & Papers / etc. |
| `hourMarkers` | String | Luminous / Roman / Arabic / etc. |
| `bezelType` | String | Timing / Fluted / Smooth / etc. |
| `sellerRating` | Float | Bob's Watches seller rating (out of 5) |
| `reviewCount` | Integer | Number of customer reviews |
| `imageUrl` | String | Listing image URL |
| `listingUrl` | String | Full URL of the listing page |
| `scrapedAt` | String | ISO timestamp of when data was scraped |

### Input Parameters

#### Mode

| Mode | Description |
|---|---|
| `search` | Search all watches by keyword |
| `byBrand` | Browse watches from a specific brand |
| `byListing` | Get details for a specific listing URL |

#### Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | Enum | `search` | Scraping mode (required) |
| `query` | String | `Rolex Submariner` | Search keyword (mode=search) |
| `brand` | Enum | `rolex` | Watch brand slug (mode=byBrand) |
| `listingUrl` | String | — | Full listing URL (mode=byListing) |
| `minPrice` | Integer | — | Minimum price filter (USD) |
| `maxPrice` | Integer | — | Maximum price filter (USD) |
| `condition` | Enum | Any | Condition filter |
| `maxItems` | Integer | `50` | Maximum number of results |

### Example Inputs

**Search for Rolex Submariner:**
```json
{
  "mode": "search",
  "query": "Rolex Submariner",
  "maxItems": 20
}
````

**Browse all Omega watches:**

```json
{
  "mode": "byBrand",
  "brand": "omega",
  "maxItems": 50
}
```

**Filter by price range:**

```json
{
  "mode": "byBrand",
  "brand": "rolex",
  "minPrice": 10000,
  "maxPrice": 30000,
  "maxItems": 100
}
```

**Get specific listing:**

```json
{
  "mode": "byListing",
  "listingUrl": "https://www.bobswatches.com/rolex/used-rolex-submariner-116610ln.html"
}
```

### Sample Output

```json
{
  "name": "Used Stainless Steel Rolex Submariner Ref 114060 Black Dial",
  "brand": "Rolex",
  "modelName": "Submariner",
  "referenceNumber": "114060",
  "condition": "Used",
  "price": 11995.00,
  "currency": "USD",
  "available": true,
  "caseMaterial": "Stainless Steel",
  "movementType": "Automatic",
  "dialColor": "Black",
  "crystalMaterial": "Sapphire",
  "yearRange": "2010 - Present",
  "gender": "Mens",
  "boxAndPapers": "Box Only",
  "hourMarkers": "Luminous",
  "bezelType": "Timing",
  "sellerRating": 4.94,
  "imageUrl": "https://www.bobswatches.com/images/submariner-114060.jpg",
  "listingUrl": "https://www.bobswatches.com/rolex/used-rolex-submariner-114060.html",
  "scrapedAt": "2026-05-25T12:00:00+00:00"
}
```

### Use Cases

- **Watch price research**: Track market prices for specific Rolex, Omega, or Patek Philippe models
- **Investment analysis**: Monitor pre-owned luxury watch value trends
- **Competitor research**: Understand pre-owned market pricing for watch dealers
- **Personal shopping**: Find certified pre-owned watches within your budget
- **Data aggregation**: Build price comparison tools for luxury watches

### Supported Brands

Rolex, Omega, Patek Philippe, Audemars Piguet, TAG Heuer, Breitling, IWC, Panerai, Cartier, Jaeger-LeCoultre, Vacheron Constantin, Longines, Tudor, Seiko, Citizen, Hublot, Richard Mille, A. Lange & Sohne, Zenith, Blancpain, Chopard, Frank Muller, Girard-Perregaux, Graham, Harry Winston, Movado, Piaget.

### FAQ

**Does this scraper require login or API keys?**
No. Bob's Watches is a public marketplace. No credentials or API keys are needed.

**How often is the data updated?**
The scraper fetches live data each time it runs. Inventory changes frequently as watches are bought and sold.

**Why are only Rolex, Omega, and similar luxury brands available?**
Bob's Watches specializes in high-end pre-owned timepieces. The brand list reflects their actual inventory.

**Can I filter by specific reference number?**
Use `mode=search` with the reference number as your query (e.g., `"query": "116610LN"`).

**What does "Box & Papers" mean?**
It indicates whether the watch comes with its original box, warranty papers, or both. "Box Only" means the box is included but not the original papers. "Box & Papers" means full documentation is included.

**Is this data free to use for commercial purposes?**
Please review Bob's Watches terms of service for commercial usage restrictions.

# Actor input Schema

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

What to fetch.

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

Keyword to search for (e.g. 'Submariner', 'Datejust 41'). Used in mode=search.

## `brand` (type: `string`):

Watch brand to browse. Used in mode=byBrand.

## `listingUrl` (type: `string`):

Full URL of a specific Bob's Watches listing page. Used in mode=byListing.

## `minPrice` (type: `integer`):

Skip listings priced below this amount (USD). 0 = no minimum.

## `maxPrice` (type: `integer`):

Skip listings priced above this amount (USD). 0 = no maximum.

## `condition` (type: `string`):

Only include listings matching this condition.

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

Maximum number of watch listings to return.

## Actor input object example

```json
{
  "mode": "search",
  "query": "Rolex Submariner",
  "brand": "rolex",
  "listingUrl": "https://www.bobswatches.com/rolex/",
  "condition": "",
  "maxItems": 50
}
```

# Actor output Schema

## `watches` (type: `string`):

Dataset containing all scraped pre-owned luxury watch listings.

# 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 = {
    "mode": "search",
    "query": "Rolex Submariner",
    "brand": "rolex",
    "listingUrl": "https://www.bobswatches.com/rolex/",
    "condition": "",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/bobs-watches-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 = {
    "mode": "search",
    "query": "Rolex Submariner",
    "brand": "rolex",
    "listingUrl": "https://www.bobswatches.com/rolex/",
    "condition": "",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/bobs-watches-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 '{
  "mode": "search",
  "query": "Rolex Submariner",
  "brand": "rolex",
  "listingUrl": "https://www.bobswatches.com/rolex/",
  "condition": "",
  "maxItems": 50
}' |
apify call crawlerbros/bobs-watches-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/bobs-watches-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bob's Watches Scraper",
        "description": "Scrape Bob's Watches, America's largest pre-owned Rolex dealer and luxury watch marketplace with 500+ certified pre-owned timepieces. Browse by brand, model, or search by keyword",
        "version": "1.0",
        "x-build-id": "dssUkEad2do8JwykZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~bobs-watches-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-bobs-watches-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/crawlerbros~bobs-watches-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-bobs-watches-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/crawlerbros~bobs-watches-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-bobs-watches-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byBrand",
                            "byListing"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Keyword to search for (e.g. 'Submariner', 'Datejust 41'). Used in mode=search.",
                        "default": "Rolex Submariner"
                    },
                    "brand": {
                        "title": "Brand (mode=byBrand)",
                        "enum": [
                            "rolex",
                            "omega",
                            "patek-philippe",
                            "audemars-piguet",
                            "tag-heuer",
                            "breitling",
                            "iwc",
                            "panerai",
                            "cartier",
                            "jaeger-lecoultre",
                            "vacheron-constantin",
                            "longines",
                            "tudor",
                            "seiko",
                            "citizen",
                            "hublot",
                            "richard-mille",
                            "a-lange-and-sohne",
                            "zenith",
                            "blancpain",
                            "chopard",
                            "frank-muller",
                            "girard-perregaux",
                            "graham",
                            "harry-winston",
                            "movado",
                            "piaget"
                        ],
                        "type": "string",
                        "description": "Watch brand to browse. Used in mode=byBrand.",
                        "default": "rolex"
                    },
                    "listingUrl": {
                        "title": "Listing URL (mode=byListing)",
                        "type": "string",
                        "description": "Full URL of a specific Bob's Watches listing page. Used in mode=byListing."
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Skip listings priced below this amount (USD). 0 = no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Skip listings priced above this amount (USD). 0 = no maximum."
                    },
                    "condition": {
                        "title": "Condition filter",
                        "enum": [
                            "",
                            "UsedCondition",
                            "RefurbishedCondition",
                            "NewCondition"
                        ],
                        "type": "string",
                        "description": "Only include listings matching this condition.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of watch listings to return.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
