Rolex APIrolex.com ↗
Access Rolex watch models, editions, full specs, pricing, user guides, brochures, and authorized retailer locations via 8 structured API endpoints.
What is the Rolex API?
The Rolex.com API exposes 8 endpoints covering the complete Rolex catalog — from model families and individual references to specifications, pricing, and authorized retailer locations. Use get_watch_edition_detail to retrieve case, dial, bracelet, and movement specs alongside US pricing for any specific reference number, or use find_store_locator to pull geocoded retailer and service center data filtered by country.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/34641cc6-f137-4ec1-96bc-b63affbf9cbb/get_all_watch_models' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace rolex-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
from parse_apis.rolex_catalog_api import Rolex, WatchModel, WatchEdition, Store, SearchResult
rolex = Rolex()
# List all watch model families
for model in rolex.watchmodels.list():
print(model.name, model.slug, model.tagline)
# Get detailed page for a specific model (constructible by slug)
submariner = rolex.watchmodel("submariner")
detail = submariner.detail()
for crumb in detail.breadcrumb:
print(crumb.title, crumb.href)
# List editions for Submariner via sub-resource
for edition in submariner.editions.list():
print(edition.name, edition.reference_number, edition.image_url)
# Get specs and pricing for a specific edition (constructible by reference_number)
sub_edition = rolex.watchedition("m124060-0001")
edition_detail = sub_edition.specs()
print(edition_detail.specs.name, edition_detail.specs.rmc)
print(edition_detail.specs.case)
print(edition_detail.specs.movement)
print(edition_detail.price.formattedPrice, edition_detail.price.currency)
# Search for watches by keyword
for result in rolex.searchresults.search(query="gold"):
print(result.title, result.uri)
# Find stores in a country
for store in rolex.stores.find(country_code="US"):
print(store.nameTranslated, store.address, store.lat, store.lng)
Get all Rolex watch model families with their names, slugs, taglines, categories, and image URLs. Returns classic, professional, and 'find your Rolex' category models. Each model includes a slug that can be used to fetch detailed model pages or edition listings.
No input parameters required.
{
"type": "object",
"fields": {
"models": "array of model objects each containing name, tagline, slug, categories, and image_url"
},
"sample": {
"data": {
"models": [
{
"name": "Submariner",
"slug": "submariner",
"tagline": "The supreme diver's watch",
"image_url": "https://media.rolex.com/image/upload/v1775074870/rolexcom/094398bf1f99/collection/hub/watches-2026-submariner-hub-portrait.jpg",
"categories": [
"pro"
]
}
]
},
"status": "success"
}
}About the Rolex API
Catalog and Model Data
The get_all_watch_models endpoint returns the full list of Rolex model families, including fields like name, tagline, slug, categories, and image_url. Models are grouped into classic, professional, and 'find your Rolex' categories. From there, get_watch_model_detail accepts a model_slug (e.g. submariner, datejust, cosmograph-daytona) and returns the full CMS page structure: breadcrumb navigation, cover media, and editorial content components.
Editions and Specifications
get_watch_editions_by_model takes a family_code and returns individual watch references with fields including reference_number, case, image_url, url, and description, plus a total count. To go deeper, pass any reference (e.g. m124060-0001) to get_watch_edition_detail, which returns a price object with formattedPrice, currency, and numeric price, plus a specs object covering case dimensions, dial color, bracelet material, and movement details.
Search and Document Access
search_watches accepts a free-text query and returns matching watches, articles, and retailer listings with title, uri, and raw metadata fields, along with a totalCount. get_user_guides_list and get_brochures_list return structured metadata for downloadable PDFs — including titles, family codes, reference numbers, and file paths — useful for building documentation or support tooling around specific references.
Store Locator
find_store_locator accepts an optional ISO 2-letter country_code and returns authorized retailers and service centers with nameTranslated, address, lat, lng, type, and hoursTranslated. This makes it straightforward to build map-based retailer finders or proximity searches for any supported country.
The Rolex API is a managed, monitored endpoint for rolex.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when rolex.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official rolex.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a watch comparison tool using specs and pricing from get_watch_edition_detail across multiple reference numbers.
- Populate a retailer map with geocoded Rolex authorized dealers filtered by country via find_store_locator.
- Index the full Rolex catalog for a luxury goods search engine using get_all_watch_models and get_watch_editions_by_model.
- Generate a reference-to-spec lookup table using the case, dial, bracelet, and movement fields from get_watch_edition_detail.
- Automate download links for user guides and brochures by family code using get_user_guides_list and get_brochures_list.
- Keyword-search the catalog for specific materials or complications (e.g. 'gold bezel', 'perpetual') using search_watches.
- Track US list prices across model families by periodically calling get_watch_edition_detail for key reference numbers.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Rolex offer an official public developer API?+
What pricing data does get_watch_edition_detail return, and which market does it cover?+
price object containing formattedPrice (e.g. '$10,100'), currency ('USD'), and a numeric price value. Pricing for other markets is not currently returned. The API covers US list prices and full technical specs. You can fork it on Parse and revise to add endpoints targeting other regional pricing pages.Does the API return secondary market or pre-owned watch data?+
How does find_store_locator filter results, and what location fields are returned?+
country_code (e.g. 'US', 'JP', 'DE') to filter results. Each establishment in the establishments array includes nameTranslated, address, lat, lng, type (retailer or service center), and hoursTranslated. The country_code parameter is optional — omitting it returns all available establishments.