# Bob's Watches Listings Scraper (`automation-lab/bobs-watches-listings-scraper`) Actor

⌚ Scrape public Bob's Watches listings for Rolex prices, availability, references, images, SKUs, and product URLs.

- **URL**: https://apify.com/automation-lab/bobs-watches-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Scrape public Bob's Watches luxury watch listings for pricing, availability, model references, images, and product URLs. Use it to monitor Rolex inventory, compare resale pricing, and export clean ecommerce product data from Bob's Watches category pages.

### What does Bob's Watches Listings Scraper do?

Bob's Watches Listings Scraper extracts structured product data from public pages on `bobswatches.com`. It is built for category pages such as Rolex, Submariner, Daytona, Datejust, GMT-Master, and filtered Bob's Watches inventory pages. The actor reads the static HTML and schema.org Product data available in the page response, so it does not need a browser for the MVP.

### Who is it for?

- ⌚ Watch dealers tracking comparable inventory.
- 📈 Resale analysts monitoring public luxury-watch prices.
- 🛒 Ecommerce teams comparing used Rolex product listings.
- 🔎 Market researchers building watch-reference datasets.
- 🧾 Operators who need repeatable exports for spreadsheets, BI tools, or alerts.

### Why use this actor?

Bob's Watches exposes useful public product metadata, but manually checking pages is slow. This actor turns those pages into a dataset with product URL, name, price, currency, availability, condition, reference number, SKU, image URL, and scrape timestamp.

### Data you can extract

| Field | Description |
| --- | --- |
| `name` | Product listing name |
| `price` | Numeric listing price when available |
| `priceCurrency` | Currency code from the product offer |
| `availability` | In-stock status from schema.org |
| `condition` | Used/pre-owned condition metadata |
| `brand` | Brand inferred or provided by structured data |
| `referenceNumber` | Reference / MPN when present |
| `sku` | Bob's Watches SKU |
| `productId` | Bob's Watches product identifier |
| `imageUrl` | Primary product image URL |
| `productUrl` | Absolute product URL |
| `sourceUrl` | Category or page URL where the item was found |
| `scrapedAt` | ISO timestamp for monitoring workflows |

### How much does it cost to scrape Bob's Watches listings?

This actor uses pay-per-event pricing. You pay a small start fee and a per-listing result fee. The input prefill is intentionally small, so your first run is cheap. Exact live prices are shown on the Apify Store page before you run the actor.

### Input

The actor accepts Bob's Watches start URLs and simple limits.

```json
{
  "startUrls": [{ "url": "https://www.bobswatches.com/rolex/" }],
  "maxItems": 25,
  "maxPagesPerUrl": 2
}
````

### Output

Each dataset item represents one watch listing or product.

```json
{
  "name": "Used Rolex Submariner Starbucks ref 126610LV Green Bezel",
  "price": 16995,
  "priceCurrency": "USD",
  "availability": "InStock",
  "condition": "UsedCondition",
  "referenceNumber": "126610LV",
  "productUrl": "https://www.bobswatches.com/used-rolex-submariner-starbucks-ref-126610lv-green-bezel.html"
}
```

### How to run

1. Open the actor on Apify.
2. Add one or more Bob's Watches category or product URLs.
3. Set `maxItems` to the number of listings you need.
4. Set `maxPagesPerUrl` if you want pagination.
5. Start the run and export the dataset as JSON, CSV, Excel, or through the API.

### Recommended start URLs

- `https://www.bobswatches.com/rolex/`
- `https://www.bobswatches.com/rolex-submariner-1.html`
- `https://www.bobswatches.com/rolex-daytona-1.html`
- `https://www.bobswatches.com/rolex-datejust-1.html`
- `https://www.bobswatches.com/rolex-gmt-master-1.html`

### Tips for reliable runs

- Start with a low `maxItems` value to validate your target page.
- Use category pages for broad inventory monitoring.
- Use filtered category URLs when you only need one model, material, or reference family.
- Keep `maxPagesPerUrl` modest for frequent monitoring jobs.
- Store the dataset between runs if you want to compare price changes.

### Integrations

You can connect the output to:

- Google Sheets or Excel for price trackers.
- Airtable for dealer inventory research.
- BI dashboards for market trends.
- Webhooks for inventory alerts.
- Your own backend through the Apify API.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bobs-watches-listings-scraper').call({
  startUrls: [{ url: 'https://www.bobswatches.com/rolex/' }],
  maxItems: 25,
  maxPagesPerUrl: 2,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/bobs-watches-listings-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.bobswatches.com/rolex/'}],
    'maxItems': 25,
    'maxPagesPerUrl': 2,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~bobs-watches-listings-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.bobswatches.com/rolex/"}],"maxItems":25,"maxPagesPerUrl":2}'
```

### MCP usage

Use this actor from Claude Code or Claude Desktop through Apify MCP:

`https://mcp.apify.com/?tools=automation-lab/bobs-watches-listings-scraper`

Add the MCP server in Claude Code:

```bash
claude mcp add apify-bobs-watches "https://mcp.apify.com/?tools=automation-lab/bobs-watches-listings-scraper"
```

Claude Desktop JSON configuration example:

```json
{
  "mcpServers": {
    "apify-bobs-watches": {
      "url": "https://mcp.apify.com/?tools=automation-lab/bobs-watches-listings-scraper"
    }
  }
}
```

Example prompts:

- "Run Bob's Watches Listings Scraper for the Rolex category and summarize the lowest priced watches."
- "Export Bob's Watches Submariner listings and identify references under $20,000."
- "Compare today's Bob's Watches Rolex inventory with yesterday's dataset."

### Legality and data source notes

This actor scrapes public web pages. It does not log in, bypass authentication, or access private account data. You are responsible for using the output in accordance with applicable laws, Bob's Watches terms, and your own compliance requirements.

### Troubleshooting

If a run returns fewer listings than expected, check whether the selected category has fewer public products or reduce filters on the Bob's Watches URL. If a URL fails, verify that it opens publicly in a browser and starts with `https://www.bobswatches.com/`.

### FAQ

#### Does it require a Bob's Watches account?

No. The actor uses public category and product pages.

#### Does it scrape sold listings?

The MVP focuses on public available product listings exposed on category and product pages. If Bob's Watches changes sold-listing visibility, test a sold URL before relying on it.

#### Can it monitor prices over time?

Yes. Schedule runs and compare `price`, `productUrl`, `sku`, and `scrapedAt` across datasets.

#### Can I scrape all Rolex models?

Yes, start with the main Rolex category and increase `maxItems` and `maxPagesPerUrl` as needed.

### Related scrapers

Explore related actors from Automation Lab:

- https://apify.com/automation-lab/jomashop-scraper
- https://apify.com/automation-lab/amazon-product-scraper
- https://apify.com/automation-lab/ebay-scraper
- https://apify.com/automation-lab/shopify-scraper

### Changelog

Initial build extracts Bob's Watches listing-level Product JSON-LD with price, availability, condition, reference, SKU, image, source URL, and scrape timestamp.

### Support

If you need a field that is visible on Bob's Watches but missing from the dataset, open an issue with a sample URL and the exact field name. Detail-page enrichment can be added in a later version if listing pages do not expose enough metadata.

Helpful issue details include:

- The Bob's Watches URL you used.
- The field you expected.
- A screenshot or page label for that field.
- Your run ID.
- Whether the page is a category, filtered category, search page, or product page.

# Actor input Schema

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

Bob's Watches category, filtered category, search, or product URLs to scrape. Good examples: /rolex/, /rolex-submariner-1.html, or a specific used watch product page.

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

Maximum number of watch listings to save across all start URLs.

## `maxPagesPerUrl` (type: `integer`):

How many paginated result pages to follow for each category URL.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.bobswatches.com/rolex/"
    }
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 2
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.bobswatches.com/rolex/"
        }
    ],
    "maxItems": 20,
    "maxPagesPerUrl": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bobs-watches-listings-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 = {
    "startUrls": [{ "url": "https://www.bobswatches.com/rolex/" }],
    "maxItems": 20,
    "maxPagesPerUrl": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bobs-watches-listings-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 '{
  "startUrls": [
    {
      "url": "https://www.bobswatches.com/rolex/"
    }
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 2
}' |
apify call automation-lab/bobs-watches-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bob's Watches Listings Scraper",
        "description": "⌚ Scrape public Bob's Watches listings for Rolex prices, availability, references, images, SKUs, and product URLs.",
        "version": "0.1",
        "x-build-id": "nSRuGbJJFrhaNNbXH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~bobs-watches-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-bobs-watches-listings-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/automation-lab~bobs-watches-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-bobs-watches-listings-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/automation-lab~bobs-watches-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-bobs-watches-listings-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Bob's Watches category, filtered category, search, or product URLs to scrape. Good examples: /rolex/, /rolex-submariner-1.html, or a specific used watch product page.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of watch listings to save across all start URLs.",
                        "default": 20
                    },
                    "maxPagesPerUrl": {
                        "title": "Maximum pages per URL",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many paginated result pages to follow for each category URL.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
