# Superdry Scraper — Products, Prices & Stock Data (`studio-amba/superdry-scraper`) Actor

Scrape products, prices, stock status, ratings, and images from Superdry.com — the UK-founded fashion brand's global storefront. Covers menswear, womenswear, outlet, and sale.

- **URL**: https://apify.com/studio-amba/superdry-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

## Superdry Scraper

Extract product data from [Superdry.com](https://www.superdry.com), the UK-founded fashion brand's global storefront. Covers menswear, womenswear, outlet, and sale.

### Why use this actor?

Superdry runs its own online store across menswear, womenswear, outlet, and sale sections, with roughly 9,450 live product pages. This actor collects structured product data — price, stock status, colour, rating, and images — without manual browsing.

Use cases include:

- **Price monitoring**: Track price and markdown changes across a section or subcategory over time
- **Competitor benchmarking**: Compare Superdry's pricing and range against other UK fashion retailers
- **Stock tracking**: Watch availability for specific styles or subcategories
- **Catalogue research**: Pull the full outlet or sale range to spot the deepest discounts
- **Assortment analysis**: See how the range breaks down by subcategory (t-shirts, jackets, shoes, etc.)

### How to scrape Superdry.com data

1. Go to the actor's page on the Apify Store
2. Pick a section (menswear, womenswear, outlet menswear, outlet womenswear, sale, or all sections)
3. Optionally narrow to one subcategory, e.g. `t-shirts`, `jackets`, `shoes`
4. Set the maximum number of results you want
5. Click "Start" to run the scraper
6. Download results as JSON, CSV, or Excel when complete

Superdry.com sits behind Cloudflare but does not challenge plain requests — no browser automation or residential proxy is needed. There is no free-text search: the site's own search pagination is disallowed by `robots.txt`, so this actor enumerates products from Superdry's own product sitemap instead and reads each product page's structured data directly.

### Input

| Field | Type | Required | Description |
|-------|------|----------|--------------|
| `section` | String | No | `mens` (default), `womens`, `outlet/mens`, `outlet/womens`, `sale`, or `all` |
| `subcategory` | String | No | Filter to one subcategory, e.g. `t-shirts`, `hoodies-and-sweatshirts`, `jackets`, `shoes`. Leave blank for every subcategory in the section. |
| `maxResults` | Integer | No | Maximum products to return (default: 100, hard cap: 9,500 — the full live catalogue) |
| `proxyConfiguration` | Object | No | Proxy settings. The default Apify proxy works — Superdry does not challenge it. |

There is no `searchQuery` field — Superdry's search results pagination is robots.txt-disallowed, so this actor works from the section/subcategory taxonomy instead.

### Output

Each product produces a JSON object with the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `name` | String | Product name |
| `brand` | String | Brand name (e.g. SUPERDRY, SDX) |
| `price` | Number | Current selling price |
| `currency` | String | Currency code (e.g. GBP) |
| `originalPrice` | Number | Pre-discount list price, when marked down. Null otherwise. |
| `color` | String | Selected colourway |
| `inStock` | Boolean | Whether the product is currently available |
| `rating` | Number | Average customer rating out of 5, when reviews exist |
| `sku` | String | Superdry's internal product/style number |
| `section` | String | Top-level catalogue section, e.g. `mens`, `outlet/womens` |
| `subcategory` | String | Subcategory, e.g. `t-shirts`, `jackets` |
| `imageUrl` | String | First product image URL |
| `imageUrls` | Array | All product image URLs |
| `productDescription` | String | Plain-text product description |
| `url` | String | Full product page URL |
| `scrapedAt` | String | ISO 8601 timestamp when data was collected |

### Example output

```json
{
    "name": "Core Essential Flip Flops",
    "brand": "SUPERDRY",
    "price": 17.99,
    "currency": "GBP",
    "originalPrice": null,
    "color": "Army Khaki",
    "inStock": true,
    "rating": 3.2,
    "sku": "268872",
    "section": "mens",
    "subcategory": "shoes",
    "imageUrl": "https://images.laguna-live.sd.co.uk/zoom/upload9223368955666919157.jpg?format=jpg&width=658",
    "imageUrls": ["https://images.laguna-live.sd.co.uk/zoom/upload9223368955666919157.jpg?format=jpg&width=658"],
    "productDescription": "Classic flip-flop design. Rubber straps with signature text...",
    "url": "https://www.superdry.com/mens/shoes/core-essential-flip-flops-268872.html",
    "scrapedAt": "2026-09-09T19:52:31.266Z"
}
```

### How it works

Superdry.com runs on Salesforce Commerce Cloud (`dwsid`/`dwanonymous_*` cookies). Its `robots.txt` disallows the AJAX pagination parameters (`start`, `srule`, `prefn*`, `prefv*`) used by the category/search grid, so this actor never touches those endpoints. Instead it enumerates product URLs from Superdry's own dedicated product sitemaps (`sitemap-customSitemap_sd-uk_en_GB_product*.xml`), filters them by section/subcategory, and reads each product page's `schema.org` Product JSON-LD block — the same structured data Google indexes — for name, description, brand, images, rating, price, currency, and availability. Both the sitemap fetch and the product-page fetch are robots.txt-allowed.

### Cost estimate

This actor uses plain HTTP requests through the standard Apify proxy — no residential proxy or browser rendering is needed, so it is one of the cheaper actors in the fleet to run. Usage cost only settles on the platform after a run reports **SUCCEEDED** — reading the dataset while a run is still in progress undercounts the eventual cost.

### Limitations

- No free-text search — filter by section and subcategory only
- Colour reflects whichever variant the product page defaults to, not every available colourway
- `originalPrice` is only populated when the page shows a strike-through list price
- Prices and stock reflect the UK storefront (GBP); other Superdry country sites are not covered by this actor

### Frequently asked questions

**Does this need a login or API key?**
No. Superdry's product pages are public, and this actor doesn't touch any account or checkout endpoints.

**How current is the data?**
Every run fetches product pages live — there is no caching layer. Price and stock reflect the moment the actor ran.

**Can I scrape the whole catalogue in one run?**
Yes, set `section` to `all` and `maxResults` to 9500 to cover every live product page. A full run will take longer and use proportionally more compute units than a single-subcategory run.

**Why is there no keyword search?**
Superdry's `robots.txt` disallows the query parameters its own search-results pagination depends on. Rather than scrape a disallowed path, this actor works from the site's own sitemap and category taxonomy instead, which is fully robots.txt-allowed.

# Actor input Schema

## `section` (type: `string`):

Which part of the catalogue to scrape. "all" scrapes every section (mens, womens, outlet/mens, outlet/womens, sale) in one run.

## `subcategory` (type: `string`):

Filter to one subcategory within the chosen section, e.g. "t-shirts", "hoodies-and-sweatshirts", "jackets", "shoes". Leave blank to scrape every subcategory in the section.

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

Stop after this many products. The full catalogue across all sections is roughly 9,450 products.

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

Superdry.com is behind Cloudflare but does not challenge plain requests — the default Apify proxy works.

## Actor input object example

```json
{
  "section": "mens",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "section": "mens",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/superdry-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 = {
    "section": "mens",
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/superdry-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 '{
  "section": "mens",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/superdry-scraper --silent --output-dataset

```

## MCP server setup

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