# Farfetch Scraper — Prices, Sizes, Boutiques & Style Codes (`studio-amba/farfetch-scraper`) Actor

Scrape Farfetch for designer clothing, bags and shoes: prices, real per-size stock, the selling boutique, images and the brandStyleId manufacturer style code you can join on across retailers. 12 markets, no login, no proxy needed.

- **URL**: https://apify.com/studio-amba/farfetch-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Farfetch Scraper

Scrape [Farfetch](https://www.farfetch.com) — the largest luxury marketplace on
the web, roughly 978,000 products from hundreds of independent boutiques — and
get back clean JSON: prices, real per-size availability, which boutique is
holding which size, images, composition, and the **manufacturer style code**.

No login. No cookies to supply. No proxy needed.

### What makes this one different

**It returns `brandStyleId`.** That is the brand's own style code — the string
printed on the hangtag and used on the designer's own website, e.g.
`855491FAEUC` for a Gucci mini bag or `P3Q81SOOO187P` for a Prada dress.

Luxury fashion has no EAN and no GTIN. Of the four big luxury retailers, only two
publish a real manufacturer code at all: Farfetch (`brandStyleId`) and
NET-A-PORTER (`mfPartNumber`). Mytheresa publishes none. Yoox exposes only its own
internal identifiers. So if you are building a cross-retailer product database,
price comparison, or resale pricing model, this field is the join key — everything
else has to be fuzzy-matched on brand plus normalised model name.

**It tells you who is actually selling.** Farfetch is a marketplace, not a shop.
The same dress is often listed by three different boutiques, in different sizes,
sometimes at different prices. This actor reports the selling boutique, where it
ships from, and — in `full` mode — which boutique holds each individual size:

```
size 38 (XS) — 2 in stock — PRADA IT
size 40 (S)  — 4 in stock — PRADA IT CENTRAL WH
size 42 (M)  — 4 in stock — KULT BOUTIQUE
```

Nothing else in the luxury space exposes that.

### Fast search mode

Farfetch does **not** use a hosted search provider. There is no Algolia,
Typesense, Constructor.io, Bloomreach or Klevu index sitting outside its bot wall
— it runs its own search behind its own GraphQL gateway. So there is no cheap
third-party index to point you at, and this actor talks to Farfetch's own API
directly.

What that API does have is two depths, and they are a real trade-off:

| | `mode: "index"` | `mode: "full"` |
|---|---|---|
| Speed | ~100 products / 9s call, 4 calls in parallel | index speed + 1 extra call per 16 products, also parallel |
| Fields | name, brand, price, was-price, discount, **available sizes**, stock quantity, category chain, images, merchant id, URL | everything in index, **plus** `brandStyleId`, the complete size ladder with per-size quantities and per-size boutique, colour + brand colour code, boutique name, ships-from city/country, composition, made-in, season, gender, size scale, editorial description |
| Not included | `brandStyleId`, boutique name, colour, composition, made-in, season, gender, description, the unavailable half of the size ladder | — |
| Best for | price monitoring, catalogue snapshots, availability tracking | cross-retailer matching, resale pricing, full product records |

Set `mode: "index"` (default) or `mode: "full"`.

**`brandStyleId` is PDP-level only.** It is not on Farfetch's listing type at all
— asking for it there returns `The field 'brandStyleId' does not exist on the type
'ProductCatalogItem'`. Same for colour, composition, season and the boutique name.
That is why `full` mode exists.

The good news is that `full` mode is nowhere near as expensive as "fetch every
product page" usually is. Farfetch's API takes 16 products per batched request,
and those requests run in parallel, so 1,000 products in full depth is about
three and a half minutes rather than the three hours a page-per-product crawl
would take.

One thing `index` mode does **not** lose: **availability is real at both depths.**
Farfetch's listing payload returns only the sizes that are currently buyable
(verified against the detail record: a Prada dress whose scale has 18 entries
listed exactly the 3 that had stock). What index mode loses is the rest of the
ladder and the per-size quantity, not the truth about what you can buy.

### How to scrape Farfetch data

1. Open the actor and set a search term, or leave it empty to browse the whole
   catalogue and filter with `brand`, `categoryId`, `minPrice` / `maxPrice`,
   `minDiscountPercent` or `onSaleOnly`.
2. Pick a depth. `index` for speed, `full` when you need style codes, boutiques
   or the complete size ladder.
3. Pick a market. Prices, currency and assortment all differ per storefront.
4. Set `maxItems` and run. Results land in the dataset as JSON, CSV, Excel or via
   the API.

You do not need a Farfetch account, an API key, cookies, or a proxy. The actor
opens one page in a headless browser to establish a session, then talks to
Farfetch's own product API for everything else.

#### A note on searching by style code

Farfetch's own search does **not** index style codes. Searching for
`855491FAEUC` returns zero results even though Farfetch stocks that exact bag,
and space-separated variants are worse — they tokenise and return unrelated
products from other houses. So you cannot go code → product on Farfetch.

Go the other way: scrape a brand or category in `full` mode and build your own
code → product index. That works, and it is what the field is for.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | array | `["gucci bag"]` | Search terms. Leave empty to browse the whole catalogue. |
| `searchQuery` | string | — | Single-term convenience alternative. |
| `mode` | enum | `index` | `index` or `full`. See the table above. |
| `market` | enum | `be` | `be`, `nl`, `fr`, `de`, `it`, `es`, `at`, `ie`, `uk`, `ch`, `se`, `dk`. |
| `maxItems` | integer | `100` | Stop after this many products. |
| `brand` | string | — | Brand name, resolved to Farfetch's brand id via their own facet. |
| `categoryId` | string | — | Farfetch category id, e.g. `141258` Women, `135971` Bags. |
| `onSaleOnly` | boolean | `false` | Only discounted products. |
| `minPrice` / `maxPrice` | integer | — | Price band in the market's currency. |
| `minDiscountPercent` | integer | — | Only products reduced by at least this much. |
| `sortBy` | enum | `RANKING` | `RANKING`, `PRICE` or `NEW_ITEMS` — the only three Farfetch offers. |
| `sortOrder` | enum | `ASC` | `ASC` or `DESC`. |
| `pageSize` | integer | `100` | Products per listing request. 100 is the ceiling. |
| `detailBatchSize` | integer | `16` | Products per batched detail request in `full` mode. 16 is the ceiling — Farfetch caps a GraphQL document at 2,048 fields. |
| `concurrency` | integer | `4` | Parallel requests. |
| `proxyConfiguration` | object | off | Leave off. See "Proxies" below. |

### Output

One record per product. Example from `mode: "full"`:

```json
{
  "name": "poplin mini-dress",
  "brand": "Prada",
  "brandStyleId": "P3Q81SOOO187P",
  "price": 1900,
  "originalPrice": null,
  "discount": null,
  "currency": "EUR",
  "sizes": [
    { "size": "36", "alternateSize": "XXS", "available": false, "quantity": 0,
      "sizeId": "19", "merchantId": null, "merchantName": null },
    { "size": "38", "alternateSize": "XS", "available": true, "quantity": 2,
      "sizeId": "21", "merchantId": "11245", "merchantName": "PRADA IT" },
    { "size": "40", "alternateSize": "S", "available": true, "quantity": 4,
      "sizeId": "23", "merchantId": "12113", "merchantName": "PRADA IT CENTRAL WH" }
  ],
  "inStock": true,
  "stockQuantity": 10,
  "category": "Day Dresses",
  "categoryPath": "Women > Clothing > Dresses > Day Dresses",
  "colour": "Blue",
  "colourCode": "F0008 BLUE",
  "imageUrl": "https://cdn-images.farfetch-contents.com/34/36/62/49/34366249_65406007_1000.jpg",
  "url": "https://www.farfetch.com/be/shopping/women/prada-poplin-mini-dress-item-34366249.aspx",
  "boutique": "PRADA IT CENTRAL WH",
  "merchantId": "12113",
  "sellerCity": "Milan",
  "sellerCountry": "Italy",
  "productId": "34366249",
  "gender": "Woman",
  "season": "AW26",
  "composition": "Polyester 65%, Cotton 35%",
  "madeIn": "Made in Italy",
  "sizeScale": "Size",
  "market": "be",
  "mode": "full",
  "scrapedAt": "2026-07-29T10:38:14.921Z"
}
```

Field-by-field descriptions are in the output schema, visible in the Console
before you run.

### Speed and cost

Farfetch's API is slow per call — 8 to 10 seconds, flat, whether you ask for one
product or a hundred. That is their backend, not this actor. Two things follow,
and both are already built in: always request the maximum page size, and run
calls in parallel (five concurrent calls finish in the time one takes).

Measured on 2026-07-29:

| Run | Result |
|---|---|
| Warm-up (once per run) | ~20–25s |
| `index`, 600 products from the Bags catalogue | 52s total, 7 API calls |
| `full`, 10 products with style codes and full size ladders | 54s total, 3 API calls |

The warm-up dominates small runs, so batch your queries into one run rather than
firing many tiny ones.

### Limitations

Worth knowing before you build on it:

- **Pagination caps at 10,000 products per query.** Beyond that Farfetch returns
  nothing. Narrow with `brand`, `categoryId` or a price band to reach the rest.
- **`brandStyleId` needs `full` mode.** It does not exist at listing level.
- **`originalPrice` is Farfetch's own previous price, not a brand RRP.** If you
  need a supplier-stated recommended retail price with a date on it, Yoox is the
  only luxury vendor that publishes one.
- **Style codes are not searchable on Farfetch.** See above.
- **One record per product, not per boutique offer.** When several boutiques sell
  the same product, the record describes the cheapest in-stock offer, and the
  per-size `merchantName` tells you where the rest of the stock sits.
- **`madeIn` is patchy.** Farfetch populates it on some products and not others.
- Prices, availability and assortment are per market and change constantly.
  Re-scrape rather than caching.

### Proxies

Leave `proxyConfiguration` off. A direct connection is what works here, and it is
free. On the two sibling luxury sites measured on the same day, Apify residential
exits returned HTTP 403 where a direct connection returned 200 — those ranges are
already badly scored by the same WAF vendor.

The setting exists as an escape hatch. If runs start failing at the warm-up step,
the outbound IP range may have been scored badly, and routing the browser through
a different exit is the one thing a retry cannot fix.

### Related scrapers

- **NET-A-PORTER Scraper** — the other luxury retailer that publishes a real
  manufacturer style code (`mfPartNumber`), and it puts the code on the search
  row, so bulk code harvesting is cheaper there. Smaller, curated, full-price.
- **Yoox Scraper** — YNAP's outlet. The only luxury vendor that states an actual
  supplier RRP with a date, which makes it the reference point for any
  discount-versus-market-price calculation.
- **Mytheresa Scraper** — curated luxury, no style code, no sizes.
- **Zalando Scraper** — mid-market European fashion at far larger volume.

### Legal

This actor reads publicly available product listings. It does not log in, does
not touch personal data, and does not access anything behind an account. You are
responsible for how you use the output, including compliance with Farfetch's
terms and with applicable law.

# Actor input Schema

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

One or more search terms, e.g. 'gucci bag' or 'prada dress'. Leave empty to browse the whole catalogue (978,000+ products) filtered by the options below. Note: Farfetch does NOT index style codes, so searching for a brandStyleId always returns zero.

## `searchQuery` (type: `string`):

Convenience alternative to Search Queries when you only want one term.

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

index = listing fields only (name, brand, price, available sizes, category, image, stock). Fast. full = also fetches each product's detail record, adding brandStyleId, the complete size ladder with per-size quantities, the selling boutique, colour, composition, made-in and the editorial description. Detail calls are batched 16 products per request, so full mode costs one extra request per 16 products rather than one per product.

## `market` (type: `string`):

Which Farfetch storefront to read. Prices, currency and assortment are per market.

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

Stop after this many products across all queries. Farfetch caps pagination at 10,000 products per query — use brand, category or price filters to reach past that.

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

Filter by brand name, e.g. 'Gucci'. Resolved to Farfetch's own brand id through their brand facet, and the log prints which one was chosen plus the near-misses (Gucci vs Gucci Kids vs Gucci Pre-Owned).

## `categoryId` (type: `string`):

Farfetch category id, e.g. 141258 Women, 141259 Men, 141260 Kids, 135967 Clothing, 135971 Bags. Read it off any Farfetch category URL.

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

Return only discounted products.

## `minPrice` (type: `integer`):

Lowest price to include, in the market's currency.

## `maxPrice` (type: `integer`):

Highest price to include, in the market's currency.

## `minDiscountPercent` (type: `integer`):

Only products reduced by at least this much.

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

Farfetch offers exactly three sort options.

## `sortOrder` (type: `string`):

Direction for the sort above. With sortBy PRICE, ASC gives cheapest first.

## `pageSize` (type: `integer`):

Products per listing request. 100 is the verified ceiling and also the right answer: a Farfetch API call takes 8-10 seconds whether you ask for 1 product or 100.

## `detailBatchSize` (type: `integer`):

Products per detail request in full mode. Farfetch caps a GraphQL document at 2,048 fields and the detail query is ~127 fields per product, so 16 is the hard ceiling (verified: 16 returns 306 KB and HTTP 200, 18 is rejected). The actor splits and retries automatically if it ever hits the limit.

## `concurrency` (type: `integer`):

Parallel requests to Farfetch. Their gateway is slow per call but parallelises well — 5 concurrent calls finished in the time one takes.

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

Leave this OFF. A direct connection is what gets past farfetch.com's Akamai protection; on the two sibling luxury sites measured on 2026-07-29, Apify residential exits returned HTTP 403 where direct returned 200. It is here as an escape hatch: if the warm-up starts failing, Akamai may be scoring the outbound IP range badly, and routing the browser through a different exit is the one thing that can fix that.

## Actor input object example

```json
{
  "searchQueries": [
    "gucci bag"
  ],
  "mode": "full",
  "market": "be",
  "maxItems": 20,
  "onSaleOnly": false,
  "sortBy": "RANKING",
  "sortOrder": "ASC",
  "pageSize": 100,
  "detailBatchSize": 16,
  "concurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 bag"
    ],
    "mode": "full",
    "market": "be",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/farfetch-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 bag"],
    "mode": "full",
    "market": "be",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/farfetch-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 '{
  "searchQueries": [
    "gucci bag"
  ],
  "mode": "full",
  "market": "be",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call studio-amba/farfetch-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=studio-amba/farfetch-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/9lCTZREnG6ub03Z6Y/builds/fdFATffSxbVzgnpXA/openapi.json