# Browns Fashion Scraper — Luxury Products, Prices & Stock (`studio-amba/brownsfashion-scraper`) Actor

Scrape Browns Fashion (brownsfashion.com), the Farfetch-owned UK multi-brand luxury boutique, for designer clothing, bags, shoes and accessories: prices, per-size stock, brand, images, EAN/SKU and category. Search by keyword, filter by collection, or pull the full catalogue. No login required.

- **URL**: https://apify.com/studio-amba/brownsfashion-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/actors/running/actors-in-store.md#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

## Browns Fashion Scraper

Scrape [Browns Fashion](https://www.brownsfashion.com) — the Farfetch-owned UK
multi-brand luxury boutique — and get back clean JSON: prices, per-size stock,
brand, images, category, and Browns' own SKU/EAN for every product.

No login. No cookies to supply.

### Why use this actor?

Browns Fashion carries hundreds of designer houses (Gucci, Burberry, Prada,
The Attico, Proenza Schouler and more) under one storefront. If you are
tracking luxury pricing, building a resale/price-comparison dataset, or
monitoring stock for a specific designer or category, this actor pulls the
whole catalogue — or just the slice you ask for — without you having to
reverse-engineer Shopify's JSON feed yourself.

### How to scrape Browns Fashion data

1. Open the actor and leave every field empty to pull the full catalogue, or
2. Set `searchQuery` to a keyword, designer name, or category (e.g. `"dress"`,
   `"gucci"`, `"sunglasses"`) to search by term, or
3. Set `collection` to a Shopify collection handle (e.g. `"accessories"`,
   `"gucci-woman"`) to scrape one category or designer line, and
4. Set `maxResults` and run. Results land in the dataset as JSON, CSV, Excel,
   or via the API.

You do not need an account, an API key, cookies, or a proxy to try it — the
actor talks directly to Browns Fashion's own Shopify storefront feed
(`products.json`, `collections/*/products.json`, `search/suggest.json`).
A residential proxy is enabled by default for reliability on larger runs (see
"Proxies" below).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQuery` | string | — | Search by keyword, brand, or category. Leave empty to browse all products. |
| `collection` | string | — | Shopify collection handle to scrape (see brownsfashion.com/collections for handles). Leave empty for all products. |
| `maxResults` | integer | `100` | Maximum number of products to return. |
| `proxyConfiguration` | object | RESIDENTIAL (GB) | Proxy settings. See "Proxies" below for why this is on by default. |

### Output

One record per product.

```json
{
  "name": "Aviator classic sunglasses",
  "brand": "Ray-Ban",
  "price": 165,
  "currency": "GBP",
  "originalPrice": null,
  "discountPercent": null,
  "ean": null,
  "sku": "OLACTY100157403",
  "productId": "10289510580488",
  "inStock": true,
  "sizes": [
    { "size": "58", "sku": "OLACTY100157403", "ean": null, "price": 165, "inStock": true }
  ],
  "category": "Accessories",
  "categories": ["Accessories", "Men", "Sunglasses", "Women"],
  "description": "These Ray-Ban sunglasses are crafted with a polished finish...",
  "imageUrl": "https://cdn.shopify.com/s/files/.../32379521_....webp",
  "imageUrls": ["https://cdn.shopify.com/..."],
  "url": "https://www.brownsfashion.com/products/ray-ban-aviator-classic-sunglasses-...",
  "source": "brownsfashion.com",
  "scrapedAt": "2026-09-07T09:12:35.302Z"
}
```

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

### Search vs collection vs full catalogue — the trade-off

Browns Fashion's Shopify feed answers these three modes with two different
endpoints, and they do not expose the same fields:

| | `collection` / full catalogue | `searchQuery` |
|---|---|---|
| Endpoint | `products.json`, `collections/*/products.json` | `search/suggest.json` + per-product detail fetch |
| Per-size stock (`inStock`) | Real (`true`/`false`) | **Not exposed** — always `null` |
| `ean` (barcode) | **Not exposed** — always `null` | Real, when Browns publishes one |
| Coverage | Full catalogue | Site's own suggest index (~10 hits) plus a filtered catalogue scan for the remainder |

Neither endpoint is a superset of the other. If you need real stock signal,
scrape by `collection` or the full catalogue. If you need the barcode, use
`searchQuery`. This actor never coerces a missing signal to `false` — a
`null` `inStock` means "this endpoint doesn't say", not "out of stock".

### Style codes

Unlike Farfetch (`brandStyleId`) or NET-A-PORTER (`mfPartNumber`), Browns
Fashion does not publish a designer manufacturer style code anywhere in its
feed — no structured tag, no `mpn` field. The `sku` field is Browns' own
internal reference (e.g. `OLRAW2600174050`), not a code you can join against
the brand's own site or another retailer. If you need a cross-retailer join
key for a specific designer, the [Farfetch Scraper](https://www.farfetch.com)
or [NET-A-PORTER Scraper](https://www.net-a-porter.com) are the ones that
publish one.

### Speed and cost

Full-catalogue and collection scans page through `products.json` at 250
products per request. Search mode makes one lightweight suggest call plus one
detail fetch per matched product (search results are typically ready in a few
seconds for the default 10-hit suggest index; scanning the full catalogue for
more matches takes proportionally longer, the same as a full-catalogue run).

This actor scrapes against Browns Fashion's native JSON API — no HTML
parsing, no browser — so the cost per result is low. A run's usage cost only
settles after it reports SUCCEEDED; reading the dataset mid-run will
undercount what you'll actually be charged.

### Limitations

- **No manufacturer style code.** See "Style codes" above.
- **`inStock` is `null` in search mode.** See the trade-off table above.
- **`ean` is `null` outside search mode.** The list endpoints used for
  `collection` and full-catalogue scraping don't include the barcode field.
- Shopify rate-limits `products.json` by IP regardless of anti-bot layer — a
  burst of unpaced requests returns HTTP 429 within seconds. This actor backs
  off and retries automatically, and a residential proxy is on by default.
- Prices and stock change constantly. Re-scrape rather than caching.

### Proxies

RESIDENTIAL (GB) is on by default. Browns Fashion has no WAF or anti-bot
challenge — Cloudflare fronts the domain but doesn't gate the JSON feed — but
Shopify rate-limits `products.json` by IP independent of that, and a shared
datacenter pool gets 429'd fast. This is the same behaviour documented on the
Antonioli and Flying Tiger scrapers, both open Shopify feeds.

### Related scrapers

- **Farfetch Scraper** — the largest luxury marketplace; publishes a real
  manufacturer style code (`brandStyleId`) and reports which boutique holds
  each size.
- **NET-A-PORTER Scraper** — curated luxury with a real manufacturer style
  code (`mfPartNumber`) on the search row itself.
- **Mytheresa Scraper** — curated luxury, no style code, no sizes.
- **Antonioli Scraper** / **Biffi Scraper** — Italian multi-brand boutiques on
  the same open-Shopify-feed pattern as this actor.

### Maintained by Studio Amba

We run 700+ scrapers for European websites, and the priority is keeping
every one of them working. Automated runs test this actor against the live
site and verify the output is complete. When the website changes, the
scraper usually gets repaired the same day, without you having to report
anything. Questions and issues go straight to the people who built it, and
most get an answer the same day.

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API, maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.

### 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
Browns Fashion's terms and with applicable law.

# Actor input Schema

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

Search for products by keyword, brand, or category (e.g. 'dress', 'gucci', 'sunglasses'). Leave empty to browse all products.

## `collection` (type: `string`):

Shopify collection handle to scrape (e.g. 'accessories', 'dresses', 'gucci'). See brownsfashion.com/collections for handles. Leave empty for all products.

## `maxResults` (type: `integer`):

Maximum number of products to return. Leave at the default for a representative slice; raise it for a full-catalogue run.

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

Browns Fashion has no WAF/anti-bot, but Shopify rate-limits by IP regardless — a burst of unpaced requests returns HTTP 429 within seconds (verified live). RESIDENTIAL proxy is required for reliable runs.

## Actor input object example

```json
{
  "searchQuery": "dress",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchQuery": "dress",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "GB"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/brownsfashion-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 = {
    "searchQuery": "dress",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "GB",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/brownsfashion-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 '{
  "searchQuery": "dress",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  }
}' |
apify call studio-amba/brownsfashion-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/brownsfashion-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/wonfaXJPDQNflfatT/builds/FPdMvbfXlLcgtyD0Z/openapi.json