# Cartier Product Scraper (`eggcenter/cartier-product-scraper`) Actor

Extract products from Cartier's online store: jewelry, watches and accessories with prices, sizes, stock, images, ratings and specs. Paste any Cartier link — category, search or product page — and get structured product data.

- **URL**: https://apify.com/eggcenter/cartier-product-scraper.md
- **Developed by:** [Egg Center](https://apify.com/eggcenter) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 output addeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Cartier Product Scraper

Collect product data from Cartier's official online store. Paste a link — the
jewelry or watches category you care about, a search-results page, or a single
product — and get back one row per piece: name, reference number, price and
currency, sizes with per-size availability, materials, category, images, and
(full model) the rating, description and technical specs. Covers bracelets,
rings, necklaces, earrings, watches, bags, fragrances and the rest of the
catalog.

### How it works

1. Paste one or more links from cartier.com. The home page collects the whole
   catalog, a category page collects that category, a search page collects
   that search, and a listing link that already carries the site's own sorting
   or filters collects exactly that view. A product link collects that one
   piece.
2. Choose how many results you want.
3. Start the actor — results appear as they are collected, so you can watch
   progress live.

Which country and currency you get follows the link you paste: an
`/en-us/` link gives US prices in USD, an `/en-gb/` link gives UK prices in GBP,
and so on. The Cartier site runs two storefront templates — the US store and
most locales on one, the UK store today on the other — and a category link
collects exactly that category on both.

### What you pay

You only pay for what the actor actually does:

| What | Price | In plain words |
| --- | --- | --- |
| Starting the actor | $0.00005 | A tiny fixed amount each time you run it. |
| Pages visited | $0.0002 | A small amount for every page the actor opens. |
| Results saved | $0.004 | The main cost — only for items that actually land in your results. |

**Example:** a run that saves 1,000 products with full details visits about
1,050 pages, so it costs about **$4.21**. The same 1,000 products without the
per-product page visits (details off) costs about **$4.01**.

You can set a maximum spend per run, and the actor stops safely when it is
reached.

### What you get

Each result contains:

| Field | What it is |
| --- | --- |
| referenceNumber | Cartier reference number, e.g. CRB7225069 |
| name | Product name as shown on the site |
| url | Link to the product page |
| price, currency | Current sales price and its currency; null for price-on-request pieces |
| inStock | Whether it can be bought online right now |
| sizes | Size options (bracelet and necklace sizes in cm) |
| variants | Per-size availability, low-stock flags and prices where the site reports them |
| materials | Metal and stones, e.g. "yellow gold" |
| category | Category path, e.g. "Jewelry > Bracelets" |
| images | Packshot URLs |
| isNew | Whether the site badges it as a new arrival |
| rating, description, specs | Customer rating, short description, technical specs (with details on) |
| requestPrice, sellableOnline | Why a price can be null; sold online vs boutique only |
| relatedVariants | Sibling designs of the same model |
| searchQuery, country, collectedAt, websiteName | Run bookkeeping |

If one of your links is broken or a page fails, you get a clearly marked error
entry for it and the run continues with the rest of your links.

### Common questions

**How much does 1,000 Cartier products cost?**
About $4.21 with full product details (roughly $4 of that is the results
themselves; the page visits add about $0.21). With details off, about $4.01.

**Can I export the results?**
Yes. Everything lands in a dataset you can download as JSON, CSV or Excel, or
read through the API while the run is still going.

**Does it get current prices and discounts?**
It gets the current sales price in the pasted link's currency. Some
high-jewelry pieces have no online price at all ("price on request") — those
come back with a null price and a `requestPrice` flag set to true, so you can
tell them apart from missing data.

**What does the "Product details" toggle do?**
With it on (recommended), the actor also opens each product's own page, which
adds the CR reference number, sizes with per-size availability, the rating,
description, technical specs and larger images. With it off, results come from
the listing pages only and runs finish several times faster.

**Can I collect from other countries?**
Paste that country's links — the reference numbers, prices and currency follow
the link. Every Cartier locale link works, and a category link collects
exactly that category on every locale.

### Need help?

Questions or problems: open an issue on the actor's Apify Store page and it
lands with the maintainer directly.

# Actor input Schema

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

Links from cartier.com where collecting starts. Paste the home page (https://www.cartier.com/en-us/home) to collect the whole catalog, a category page for that section, a search-results link for that search, or any listing link with the website's own sorting or filters in it (such as ?srule=price-low-to-high) — the actor collects exactly what that link shows. A single product page link collects that one product. Locale follows the link: paste an /en-gb/ link for UK prices in GBP, for example.

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

Stop after this many items (0 = no limit).

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

Apify Proxy settings. Uses the datacenter group unless residential is explicitly selected.

## `includePdpDetails` (type: `boolean`):

On (recommended): every collected piece is also opened on its own product page, which adds the CR reference number, sizes with per-size availability, description, rating and technical specs, and sharper 750px images. Off: results come from the listing grid only and run several times faster.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.cartier.com/en-us/jewelry/bracelets/"
    }
  ],
  "maxItems": 24,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "includePdpDetails": true
}
```

# Actor output Schema

## `results` (type: `string`):

All collected Cartier products, one item per row. Broken or unsupported input links appear as clearly marked error rows and never stop the run.

# 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.cartier.com/en-us/jewelry/bracelets/"
        }
    ],
    "maxItems": 24,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("eggcenter/cartier-product-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.cartier.com/en-us/jewelry/bracelets/" }],
    "maxItems": 24,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("eggcenter/cartier-product-scraper").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 '{
  "startUrls": [
    {
      "url": "https://www.cartier.com/en-us/jewelry/bracelets/"
    }
  ],
  "maxItems": 24,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call eggcenter/cartier-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,eggcenter/cartier-product-scraper"
        }
    }
}
```

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/uMngDunw1L9AsIYwg/builds/aMuYlUj8Gshrp324H/openapi.json