# Farfetch Luxury Fashion Price & Discount Extractor (`nimbryxo-studio/farfetch-luxury-fashion-price-and-discount`) Actor

Search Farfetch.com by keyword, brand, gender, new arrivals or sale items to get price, original price, discount percent, color, category and designer for each luxury fashion product.

- **URL**: https://apify.com/nimbryxo-studio/farfetch-luxury-fashion-price-and-discount.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 25.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 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/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

## Farfetch Luxury Fashion Price & Discount Extractor

Farfetch brings together luxury fashion from boutiques and designer brands around the world. This actor searches Farfetch by keyword, browses a brand or a full category, lists new arrivals and sale items, or looks up specific product URLs. Every product comes back as a structured record with local pricing, discount, sizes, color, stock, category, images and product details.

### What this actor does

- Searches Farfetch products by free-text keyword
- Browses a designer's catalogue
- Browses live women's, men's and kids' categories — clothing, shoes, bags, accessories, jewellery, watches, pre-owned, activewear, lingerie and homeware
- Lists new arrivals and currently discounted sale items, optionally filtered by gender
- Filters listings by color, price band, discount band and sort order
- Scrapes any Farfetch listing URL, including sale-category and combined-filter pages
- Fetches full product details for a list of Farfetch product URLs, including the seller/boutique and brand style code
- Supports 17 regional storefronts with local currencies, including USD, GBP, EUR, HKD, CNY, SGD, JPY and more
- Empty fields are omitted — a field only appears when Farfetch published that data for the product

### Data source

Farfetch's global `farfetch.com` host blocks automated HTTP access. This actor uses Farfetch's publicly accessible regional storefronts on `farfetch.cn`, which expose the same global product IDs through server-rendered product pages — no login, account or cookies required. Product pages also embed the seller (boutique) and brand style code in their hydration state, so those fields are read without extra requests.

Prices, discounts and availability are local to the selected storefront. Use the `locale` input to choose the market and currency. For USD, use `nz`; for GBP, `uk`; for EUR, choose `fr`, `de`, `it`, `es` or `ie`.

### Output per product

- `productId` — Farfetch's internal product ID
- `brand` — brand/designer label on the product
- `title` — product name
- `price` — current (final/discounted) price in the selected storefront's currency
- `originalPrice` — pre-discount price, when the item is on sale
- `discountPercent` — total discount percentage against `originalPrice`, when on sale
- `discountAmount` — absolute amount saved, when on sale
- `saleDiscountPercent` — Farfetch's sale-stage discount percentage shown on sale listings; the `discountRange` filter follows this value
- `currency` — currency code (USD, GBP, EUR, HKD, CNY, …)
- `locale` — storefront used for the record
- `color` — product color (product-details mode)
- `condition` — `new` or `used`, from Farfetch's product condition (product-details mode)
- `category` — deepest category in the product breadcrumb, e.g. `Shoulder Bags` (product-details mode)
- `categories` — full category breadcrumb below the brand, e.g. `["Bags", "Shoulder Bags"]` (product-details mode)
- `gender` — women, men or kids, when known
- `imageUrl` — primary product image URL
- `images` — all product image URLs
- `productUrl` — direct link to the product on the selected storefront
- `sizes` — available size labels, when listed
- `variants` — per-size records with `sku`, `size`, `price`, `originalPrice`, `discountPercent`, `discountAmount`, `currency`, `availability`, `returnDays` and `returnFees` (product-details mode)
- `description` — product description (product-details mode)
- `boutique` — seller/boutique name published on the product page (product-details mode)
- `styleCode` — brand style ID published on the product page (product-details mode)
- `availability` — stock status such as `InStock`
- `stockQuantity` — units Farfetch reports in stock for the listing item (listing modes)
- `position` — rank of the product in the returned result order (listing modes)
- `returnDays` — return window in days, when Farfetch publishes it
- `returnFees` — return-fee policy, such as `FreeReturn`, when published
- `designer` — designer name, when distinct from `brand`
- `material` — product material/composition, when listed
- `mode` — which scraping mode produced this record
- `scrapedAt` — ISO timestamp when the record was collected

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search`, `searchByBrand`, `category`, `newIn`, `saleItems`, `listingUrls`, or `productDetails` |
| `locale` | string | `nz` | Storefront and currency: `nz` (USD), `uk` (GBP), `fr`/`de`/`it`/`es`/`ie` (EUR), `hk`/`mo` (HKD), `cn` (CNY), `sg` (SGD), `jp` (JPY), `kr` (KRW), `au` (AUD), `ca` (CAD), `ae` (AED), `tw` (TWD) |
| `keyword` | string | `Gucci bag` | Search keyword, used in `search` mode |
| `brand` | string | – | Brand name or slug (e.g. `gucci`, `prada`), used in `searchByBrand` mode |
| `gender` | string | – (women for listings) | `women`, `men`, or `kids` for search, brand, new-arrivals and sale modes |
| `category` | string | `women/bags-purses-1` | Live category path for `category` mode, e.g. `women/bags-purses-1`, `men/shoes-2`, `kids/girls-clothing-4` |
| `sortBy` | string | `recommended` | `recommended`, `newest`, `priceHighToLow`, `priceLowToHigh`, or `saleHighToLow` |
| `colors` | array | – (all colors) | Color filter: `Black`, `White`, `Grey`, `Neutrals`, `Brown`, `Green`, `Blue`, `Red`, `Pink`, `Yellow`, `Metallic`, `Multicolour`, `Gold`, `Silver`, `Purple`, `Orange` |
| `priceMin` | integer | – | Lowest price to include, in the storefront currency |
| `priceMax` | integer | – | Highest price to include, in the storefront currency |
| `discountRange` | string | – (any) | Farfetch sale-discount band: `none`, `upTo30`, `30to50`, `50to60`, or `60plus`. The matching value per product is `saleDiscountPercent`. |
| `listingUrls` | array | `[]` | Farfetch category, brand, sale, set or search listing URLs, used in `listingUrls` mode. Both `.com` and `.cn` URLs are accepted. |
| `productUrls` | array | `[]` | Farfetch product page URLs to scrape directly, used in `productDetails` mode. Both `.com` and `.cn` URLs are accepted. |
| `maxItems` | integer | `20` | Maximum number of products to return (1–2500) |

`category` mode follows the department in the selected category path, so `gender` is not combined with it. The other listing modes use `gender`; when it is empty they use the women's storefront.

#### Example: keyword search in USD

```json
{
  "mode": "search",
  "keyword": "Prada shoes",
  "locale": "nz",
  "maxItems": 30
}
```

#### Example: women's bags under 1,500 USD, cheapest first

```json
{
  "mode": "category",
  "category": "women/bags-purses-1",
  "locale": "nz",
  "priceMax": 1500,
  "sortBy": "priceLowToHigh",
  "maxItems": 50
}
```

#### Example: black or brown men's shoes on sale

```json
{
  "mode": "category",
  "category": "men/shoes-2",
  "locale": "uk",
  "colors": ["Black", "Brown"],
  "discountRange": "30to50",
  "sortBy": "saleHighToLow",
  "maxItems": 40
}
```

#### Example: everything from one designer, women's only, GBP

```json
{
  "mode": "searchByBrand",
  "brand": "balenciaga",
  "gender": "women",
  "locale": "uk",
  "maxItems": 50
}
```

#### Example: new arrivals in EUR

```json
{
  "mode": "newIn",
  "gender": "women",
  "locale": "fr",
  "sortBy": "newest",
  "maxItems": 40
}
```

#### Example: scrape a filtered listing URL

```json
{
  "mode": "listingUrls",
  "listingUrls": [
    "https://www.farfetch.com/uk/shopping/women/sale/bags-purses-1/items.aspx?sort=5&colour=1&price=100-2000"
  ],
  "locale": "uk",
  "maxItems": 60
}
```

#### Example: look up specific products

```json
{
  "mode": "productDetails",
  "locale": "nz",
  "productUrls": [
    "https://www.farfetch.com/shopping/women/gucci-gg-marmont-shoulder-bag-item-12345678.aspx"
  ]
}
```

### Use cases

- **Price monitoring** — track a designer's catalog or a whole category for price changes and new discounts in a chosen market
- **Sale tracking** — pull sale items or discount bands regularly to catch markdowns as they appear
- **Category research** — compare pricing and stock across women's, men's and kids' categories in different markets
- **Trend forecasting** — scan new arrivals by gender to see what's launching across brands
- **Catalog enrichment** — feed product URLs through `productDetails` to backfill price, sizes, color, condition, category and material data

### FAQ

**Do I need a Farfetch account or cookies?** No. Only publicly available product listings are read; no login, account or cookies are required.

**Which market and currency should I use?** Use the `locale` that matches your target market. `nz` returns USD, `uk` returns GBP, `fr`/`de`/`it`/`es`/`ie` return EUR, and the other options return their local currencies. Farfetch prices are market-local, so the same product can cost different amounts in different storefronts.

**Why does a product have no `originalPrice` or `discountPercent`?** Those fields only appear when the item is actually marked down; full-price items simply don't carry a discount.

**What do `category` and `categories` mean?** Farfetch groups products in a breadcrumb below the brand. `categories` keeps the full trail and `category` is the deepest one, so a bag can come back as `["Bags", "Shoulder Bags"]` and `Shoulder Bags`.

**What is `condition`?** Farfetch marks new products as `new` and pre-owned products as `used`. Pre-owned listings often also have a Pre-Owned category in the breadcrumb.

**Can I filter by size?** Size filtering is not exposed as an input. Farfetch's listing URL accepts only opaque internal numeric size IDs; letter sizes return a server error and the same ID means different labels on different size scales. Sizes are reported per product in `sizes` and per variant in `variants`, so filter the dataset on those fields after the run.

**Can I combine filters?** Yes — category, brand or search mode can be combined with `gender`, `sortBy`, `colors`, `priceMin`, `priceMax` and `discountRange` in one run.

**How many products can one run return?** Up to `maxItems`, capped at 2500. Listings return up to 180 products per page and paginate until the items run out; the source has no fixed page ceiling. For more than 2500, run separate categories, brands, price bands or discount bands and combine the datasets — deduplicate on `productId`.

**Do I get the boutique and brand style code?** Yes, in `productDetails` mode: `boutique` is the seller name and `styleCode` is the brand style ID. Farfetch-owned products do not publish a boutique name, so that field is omitted for those records.

**Why do some category URLs return no products?** Farfetch uses different category paths in different markets. Use the `category` dropdown, which contains only verified live paths, or search by keyword or brand.

**Does Farfetch publish product ratings or reviews?** No. The regional product pages carry no per-product rating, review count or review text; the "4.7/5 stars" copy is Farfetch's site-wide marketing, not a product rating. Those fields are therefore not emitted.

**Are prices the same as farfetch.com US?** No. The global `farfetch.com` host blocks automated access, so this actor uses Farfetch's regional storefronts. Prices and availability are local to the selected storefront and should be treated as market-specific.

**Is this affiliated with Farfetch?** No. This is an independent, third-party actor that reads Farfetch's publicly available product pages; it is not operated by or affiliated with Farfetch.

# Actor input Schema

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

What to browse on Farfetch.

## `locale` (type: `string`):

Regional Farfetch storefront. Prices and availability are local to the selected market.

## `keyword` (type: `string`):

Product keyword to search for (mode=search), e.g. 'Gucci bag', 'Prada shoes'.

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

Brand name or slug to browse (e.g. 'gucci', 'prada', 'balenciaga').

## `gender` (type: `string`):

Filter by gender for search, brand, new-arrivals and sale modes. Category mode follows the department in the selected category. When omitted, listings use the women's storefront.

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

Farfetch department and category to browse. Each option is a live catalog path, e.g. 'Women - Bags' or 'Men - Shoes'.

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

Order of listing results. Applies to search, brand, category, new-arrivals and sale modes.

## `colors` (type: `array`):

Only include products in these colors. Leave empty for every color.

## `priceMin` (type: `integer`):

Lowest price to include, in the selected storefront's currency. Leave empty for no minimum.

## `priceMax` (type: `integer`):

Highest price to include, in the selected storefront's currency. Leave empty for no maximum.

## `discountRange` (type: `string`):

Only include products in this Farfetch sale-discount band. The matching value per product is saleDiscountPercent. Applies to search, brand, category, new-arrivals and sale modes.

## `listingUrls` (type: `array`):

Farfetch category, brand, sale, set or search listing URLs. Both farfetch.com and farfetch.cn URLs are accepted; every listing starts at page 1 with 180 products per page.

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

Farfetch product page URLs to scrape. Both farfetch.com and farfetch.cn URLs are accepted and converted to the selected storefront.

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

Maximum number of products to return (1-2500).

## Actor input object example

```json
{
  "mode": "search",
  "locale": "nz",
  "keyword": "Gucci bag",
  "gender": "",
  "category": "women/bags-purses-1",
  "sortBy": "recommended",
  "colors": [],
  "discountRange": "",
  "listingUrls": [],
  "productUrls": [],
  "maxItems": 3
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset of scraped Farfetch products.

# 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",
    "locale": "nz",
    "keyword": "Gucci bag",
    "gender": "",
    "productUrls": [],
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/farfetch-luxury-fashion-price-and-discount").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",
    "locale": "nz",
    "keyword": "Gucci bag",
    "gender": "",
    "productUrls": [],
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/farfetch-luxury-fashion-price-and-discount").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 '{
  "mode": "search",
  "locale": "nz",
  "keyword": "Gucci bag",
  "gender": "",
  "productUrls": [],
  "maxItems": 3
}' |
apify call nimbryxo-studio/farfetch-luxury-fashion-price-and-discount --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/farfetch-luxury-fashion-price-and-discount"
        }
    }
}
```

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/pvyZfFA3yzYwp4gwc/builds/iCRcK5JGIZAx78Tsn/openapi.json
