# Cettire Product Scraper (`axlymxp/cettire-product-scraper`) Actor

Scrape Cettire luxury fashion products: price, original price, discount %, stock, designer style code, images and per-size availability, localised for 67 markets. Search, brand, product URL or full-catalogue modes. No login or browser needed. Pay only for the results you get.

- **URL**: https://apify.com/axlymxp/cettire-product-scraper.md
- **Developed by:** [axly](https://apify.com/axlymxp) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 dataset items

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

## Cettire Product Scraper — luxury prices, discounts & stock in 67 markets

Extract structured product data from **Cettire** (cettire.com), the luxury fashion
marketplace listing about 350,000 products from 2,600+ designers. Each product comes
with its **current price, original price and discount %**, stock level, designer style
code, images and, optionally, **per-size availability**. Prices are localised for any
of Cettire's **67 markets** (USD, GBP, EUR, AUD, JPY, HKD, AED and more).

Search by keyword, pull a designer's entire range, look up specific product URLs, or
crawl the **complete catalogue**. No login, no browser and no cookies are needed.

### Who uses this

| Buyer | What they do with it |
| --- | --- |
| **Brand protection & pricing teams** | Track how deeply Cettire discounts your brand, market by market and week by week |
| **Resellers & arbitrage buyers** | Find the deepest markdowns and compare the same item's price across markets |
| **Equity analysts (ASX: CTT)** | Monitor catalogue depth, stock and discounting over time |
| **Fashion-data / PIM developers** | Feed a stable JSON schema into price-comparison or product-matching pipelines |

### What you get

| Field | Example | Notes |
| --- | --- | --- |
| `brand` | `Gucci` | designer |
| `title` | `Gucci Jackie 1961 Medium Shoulder Bag` | |
| `url` | `https://www.cettire.com/products/…` | |
| `price` / `compare_at_price` | `3203.33` / `4504.95` | in the market currency |
| `discount_percent` / `on_sale` | `28.9` / `true` | |
| `currency` / `country` | `USD` / `US` | 67 markets |
| `in_stock` / `inventory_quantity` | `true` / `3` | |
| `designer_model_number` | `875056FAF8N` | style code for matching across retailers |
| `designer_color` / `color` | `9651` / `Beige` | |
| `department` / `category` / `product_type` | `women` / `bags` / `Shoulder Bags` | |
| `image` / `images` | CDN URLs | |
| `tags`, `final_sale`, `published_at`, `updated_at` | | |
| `details` *(optional)* | description, composition, made-in, dimensions, SKU, barcode, **sizes\[] with stock per size** | turn on **Include product details** |

### Use cases

1. **Weekly grey-market watch for your brand.** Schedule a brand run with
   `onSaleOnly` and diff each week's discounts in Sheets or BigQuery.
2. **Cross-market price arbitrage.** Run the same brand for `US`, `GB` and `HK`, then
   join on `handle` to find the cheapest market for each item.
3. **Match Cettire to other retailers.** Join on `designer_model_number` against
   Farfetch, SSENSE or MR PORTER data.
4. **New-arrival monitoring.** Set `publishedWithinDays: 7` to capture only what
   Cettire listed this week.
5. **Full catalogue snapshots** for research, assortment analysis or ML training
   data.

### Input

| Parameter | Description | Default |
| --- | --- | --- |
| `searchQueries` | Keyword searches, e.g. `gucci shoulder bag` | `[]` |
| `brands` | Exact designer names; each brand's full range | `[]` |
| `productUrls` | Product URLs (any locale) or handles → full detail rows | `[]` |
| `fullCatalog` | Crawl every brand (combine with filters to narrow) | `false` |
| `department` / `category` / `productType` | Filters (women / men / kids / homeware; clothing / bags / shoes / accessories) | any |
| `onSaleOnly` / `inStockOnly` | Only discounted / only in-stock products | `false` |
| `publishedWithinDays` | New arrivals only (0 = off) | `0` |
| `sortBy` | relevance, newest, price asc/desc, biggest discount | relevance |
| `country` | Market for prices & availability | `US` |
| `includeDetails` | Adds description, composition, per-size stock | `false` |
| `maxItemsPerQuery` / `maxItems` | Per-query cap / whole-run cap (0 = unlimited) | `100` / `0` |

#### Example input

```json
{
  "brands": ["Bottega Veneta"],
  "category": "bags",
  "onSaleOnly": true,
  "country": "GB",
  "maxItemsPerQuery": 0,
  "includeDetails": true
}
```

#### Example output (one row, real data)

```json
{
  "product_id": "cmVhY3Rpb24vcHJvZHVjdDplTTlNNllkSm9hcTdBWUZLYQ==",
  "handle": "loewe-mini-puzzle-fold-tote-bag-928583014",
  "url": "https://www.cettire.com/products/loewe-mini-puzzle-fold-tote-bag-928583014",
  "title": "Loewe Mini Puzzle Fold Tote Bag",
  "brand": "Loewe",
  "brand_handle": "loewe",
  "department": "women",
  "category": "bags",
  "product_type": "Tote Bags",
  "color": "Black",
  "designer_color": "1100",
  "designer_model_number": "A657V25X01",
  "price": 1545.95,
  "compare_at_price": 2050.38,
  "discount_percent": 24.6,
  "on_sale": true,
  "currency": "USD",
  "country": "US",
  "in_stock": true,
  "inventory_quantity": 3,
  "final_sale": false,
  "image": "https://d3vfig6e0r0snz.cloudfront.net/rcYjnYuenaTH5vyDF/images/products/b9333ee71e394a651b27638579f5ffb5.jpg",
  "tags": ["Tote Bags", "Women", "Loewe", "Season_Carry", "Bags"],
  "published_at": "2023-08-31T01:03:27.000Z",
  "source": "search:loewe puzzle",
  "scraped_at": "2026-09-24T07:12:08Z",
  "details": {
    "composition": "100% Calf Leather",
    "made_in": "Spain",
    "dimensions": "Width: 17cm, Height: 20.5cm, Depth: 10cm",
    "highlights": ["Mini tote bag silhouette", "Black calf leather construction", "Removable shoulder strap"],
    "sizes": [{"size": "Only One Size", "available": 3, "is_sold_out": false, "price": 1545.95, "compare_at_price": 2050.38}],
    "sizes_in_stock": ["Only One Size"]
  }
}
```

### How it works and how reliable it is

The actor reads the same catalogue APIs that Cettire's own website and app use,
so it does not need to beat an anti-bot wall. Large result sets are split into
small exact slices (by product type, department and colour), which means brand and
full-catalogue runs return every product rather than an overlapping sample.
Duplicates are removed by product ID.

Runs checkpoint after every brand or query. If a run is migrated or restarted, it
resumes where it left off without duplicate rows.

### Scheduling, webhooks & integrations

- **Schedule** daily or weekly runs in Apify Console (Schedules) to build price history.
- **Webhooks**: trigger your pipeline on `ACTOR.RUN.SUCCEEDED`.
- **Export** to CSV, Excel or JSON, or connect Google Sheets, Make, Zapier, n8n,
  Airbyte or S3.
- **API**: `POST https://api.apify.com/v2/acts/<username>~cettire-product-scraper/run-sync-get-dataset-items`.

### Use with AI assistants (MCP)

Add this actor to Claude, Cursor or any MCP client through the
[Apify MCP server](https://mcp.apify.com). Your assistant can then answer questions
such as *"What are the ten deepest Prada discounts on Cettire UK right now?"* by
calling the actor with `brands: ["Prada"]`, `country: "GB"` and `sortBy: "discount_desc"`.

### FAQ

**How fresh is the data?** Every run reads Cettire's live catalogue, so prices,
discounts and stock are current at the moment of the run.

**How many products can I get?** Everything Cettire lists. A single brand typically
takes seconds to a couple of minutes. A full-catalogue crawl (~350k products) takes
a few hours, and `maxItems` caps any run.

**Do I need a proxy?** No. The proxy setting is only a fallback: if Cettire
rate-limits a very large crawl, the run switches to proxy sessions automatically.

**Which prices do I get?** The prices shown to shoppers in the chosen `country`,
in that market's currency. Run once per market to compare.

**Why do some rows have `details: null`?** Details are fetched only when
**Include product details** is on (URL inputs always include them). If a single
detail call fails, the row is still delivered without it.

**Is this legal?** The actor collects publicly available product and price
information. It does not log in and does not access personal data. You are
responsible for using the data in line with applicable laws and Cettire's terms.

**Is this affiliated with Cettire?** No. This is an independent tool and is not
endorsed by Cettire Limited.

**Something broke?** Open an issue on the actor's Issues tab. Failures also alert
the maintainer automatically.

# Actor input Schema

## `searchQueries` (type: `array`):

Keyword searches, exactly as typed into Cettire's search box (e.g. "gucci bag", "prada loafers").

## `brands` (type: `array`):

Exact designer names as shown on Cettire (e.g. "Prada", "Saint Laurent", "Bottega Veneta"). Each brand's complete product list is scraped (combined with the filters below).

## `productUrls` (type: `array`):

Cettire product URLs (https://www.cettire.com/products/<handle>, any country prefix) or bare handles. Returns full product detail, including per-size stock.

## `fullCatalog` (type: `boolean`):

Crawl every brand on Cettire (~350,000 products). Combine with the filters below to narrow it (e.g. women's bags on sale). Large runs take a while; use maxItems to cap them.

## `department` (type: `string`):

Restrict to one department.

## `category` (type: `string`):

Restrict to one top-level category.

## `productType` (type: `string`):

Optional exact product type, e.g. "Shoulder Bags", "Sneakers", "Coats".

## `onSaleOnly` (type: `boolean`):

Only products with a discount (price below the compare-at price).

## `inStockOnly` (type: `boolean`):

Skip products with zero inventory.

## `publishedWithinDays` (type: `integer`):

Only products published in the last N days (0 = no limit). Sorting switches to Newest unless you set Sort by.

## `sortBy` (type: `string`):

Result ordering. Affects which products you get when a cap applies.

## `country` (type: `string`):

Which Cettire storefront to price products for. Prices, currency and availability are localised per market.

## `includeDetails` (type: `boolean`):

Add description, composition, made-in, barcode and per-size stock for every row (one extra request per product; billed as a separate event).

## `maxItemsPerQuery` (type: `integer`):

Cap for each search query and each listed brand (0 = no limit). Ignored for full-catalogue crawling; use Max results in total for that.

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

Stop the whole run after this many products (0 = no limit).

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

Cettire's API needs no proxy. It is used only if Cettire rate-limits the run's IP on very large crawls. The run then switches to these proxy sessions automatically.

## Actor input object example

```json
{
  "searchQueries": [
    "gucci shoulder bag"
  ],
  "fullCatalog": false,
  "department": "",
  "category": "",
  "onSaleOnly": false,
  "inStockOnly": false,
  "publishedWithinDays": 0,
  "sortBy": "rank_score",
  "country": "US",
  "includeDetails": false,
  "maxItemsPerQuery": 100,
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every scraped Cettire product (price, discount, stock, style code, images, optional per-size detail) as a structured JSON row.

## `summary` (type: `string`):

Totals for the run (rows pushed, API requests).

# 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 = {
    "searchQueries": [
        "gucci shoulder bag"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axlymxp/cettire-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 = {
    "searchQueries": ["gucci shoulder bag"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("axlymxp/cettire-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 '{
  "searchQueries": [
    "gucci shoulder bag"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call axlymxp/cettire-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axlymxp/cettire-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/tcvKWcFR9B9aX7uGA/builds/tS6PmYtY7znZSHm5n/openapi.json