# END. Scraper — Streetwear & Sneaker Prices, Stock & Images (`studio-amba/endclothing-scraper`) Actor

Scrape END. (endclothing.com), the UK multi-brand luxury streetwear and sneaker retailer, for prices, stock status, brand, images, category and SKU. Search by brand or category, or scrape specific product URLs. No login required.

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

## END. (endclothing.com) Scraper

Scrape [END.](https://www.endclothing.com) — the UK multi-brand luxury
streetwear and sneaker retailer — and get back clean JSON: prices, stock
status, brand, images, category and SKU for every product.

No login. No cookies to supply.

### Why use this actor?

END. carries hundreds of streetwear and sneaker brands (Nike, adidas,
Stone Island, Carhartt WIP, Acne Studios, A.P.C. and more) under one
storefront. If you're tracking sneaker/streetwear pricing, building a
resale or price-comparison dataset, or monitoring a specific brand or
category, this actor pulls product data without you having to
reverse-engineer the site's Magento backend yourself.

### How to scrape END. data

1. Leave every field empty to pull END.'s "New In" listing, or
2. Set `brands` to one or more brand names (e.g. `"Nike"`, `"A.P.C."`) to
   scrape a brand's page, or
3. Set `categoryUrls` to one or more category paths (e.g. `"footwear/boots"`,
   `"clothing"`, `"accessories/bags"`, `"sale/all-sale"`) to scrape a
   category, or
4. Set `productUrls` to scrape specific products directly, and
5. Set `maxItems` 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 (usually) a proxy — the
actor reads END.'s own server-rendered product and category pages directly.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `brands` | array of strings | — | Brand names, e.g. `["Nike", "Stone Island"]`. Resolved to the brand's page on END. |
| `categoryUrls` | array of strings | — | Category paths, e.g. `["footwear/boots", "clothing"]`, or full URLs. |
| `productUrls` | array of strings | — | Direct product page URLs to scrape, skipping listing discovery. |
| `country` | string | `gb` | Storefront/country to read (`gb`, `us`, `ie`, `eu`, `be`, `nl`, `it`, `es`, `dk`, `se`, `au`, `ca`, `nz`, `jp`, `kr`, `sg`, `hk`, `cn`, `tw`, `de`, `fr`). Prices and currency follow the country's own storefront. |
| `maxItems` | integer | `100` | Maximum number of products to return. |
| `concurrency` | integer | `5` | Parallel product-page requests. |
| `proxyConfiguration` | object | Apify Proxy (automatic) | Proxy settings. See "Proxies" below. |

If every field is left empty, the actor scrapes END.'s "New In" listing so a
default `{}` run still returns real, current data.

### Output

One record per product.

```json
{
  "name": "END. Cord Monogram Jacket",
  "brand": "END.",
  "price": 199,
  "currency": "GBP",
  "originalPrice": null,
  "sku": "END-CMONJK-SND",
  "productId": "END-CMONJK-SND",
  "inStock": true,
  "category": "Coats & Jackets",
  "categories": ["Mens", "Clothing", "Coats & Jackets"],
  "description": "Buy END. Cord Monogram Jacket - Dark Sand from END. (UK) - only £199. Fast shipping on latest END.",
  "imageUrl": "https://media.endclothing.com/media/catalog/product/B/R/BR_END-CMONJK-SND_1_1.jpg",
  "imageUrls": [
    "https://media.endclothing.com/media/catalog/product/B/R/BR_END-CMONJK-SND_1_1.jpg",
    "https://media.endclothing.com/media/catalog/product/B/R/BR_END-CMONJK-SND_2_1.jpg"
  ],
  "url": "https://www.endclothing.com/gb/end-cord-monogram-jacket-end-cmonjk-snd.html",
  "country": "gb",
  "sourceListingUrl": "https://www.endclothing.com/gb/new-in",
  "source": "endclothing.com",
  "scrapedAt": "2026-09-14T09:20:00.000Z"
}
```

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

### How brand and category pages are found

Brand names are matched to END.'s own URL slug the same way the site itself
does it most of the time (lowercase, spaces to dashes) — but a handful of
brand slugs on END. don't follow that pattern exactly (e.g. "C.P. Company"
is `cp-company`, not `c-p-company`). If a brand you pass in returns nothing,
open the brand's page on endclothing.com and pass the exact slug from the
URL as a `categoryUrls` entry instead (e.g. `"brands/cp-company"`).

### Coverage per page

END.'s category and brand pages list up to **120 products** each and do not
support server-side pagination past that (`?p=2` returns the identical page
to `?p=1` — verified live). To scrape more than 120 products from one brand
or category, narrow further (e.g. by sub-category) or combine several
`categoryUrls` / `brands` entries — the actor de-duplicates products it has
already seen across all of them.

### Limitations

- **No per-size stock.** END. only exposes per-size/variant availability
  through a client-side API call that sits behind an enforced Akamai bot
  challenge (verified: a direct request gets Akamai's real block page, not
  a soft signal). `inStock` reflects the whole product (in stock / sold
  out), not individual sizes.
- **No "was" price on sale items.** Checked a live sale category and one of
  its products directly — END.'s server-rendered pages only expose the
  current selling price, never an original/struck-through price.
- **No free-text keyword search.** END.'s `/catalogsearch/` path is
  disallowed by robots.txt, so this actor doesn't offer one. Use `brands`,
  `categoryUrls`, or `productUrls` instead.
- **120 products per brand/category page.** See "Coverage per page" above.
- Prices and stock change constantly. Re-scrape rather than caching.
- A run's usage cost only settles after it reports SUCCEEDED — reading the
  dataset mid-run will undercount what you'll actually be charged.

### Cost estimate

This actor scrapes plain server-rendered HTML — no browser, no API — so the
cost per result is low, one request per product plus one per brand/category
page for discovery. On the default (MID) pricing tier that's a few
thousandths of a dollar per result. A run's usage cost only settles after it
reports SUCCEEDED — reading the dataset mid-run will undercount what you'll
actually be charged.

### Proxies

Apify Proxy (automatic, no group) is the default. END.'s product and
category pages are not behind an anti-bot wall — verified live with a plain
request and no proxy at all — so a datacenter/automatic pool is enough for
normal use. Only END.'s internal REST API and Algolia search endpoint are
gated, and this actor never calls them. If you start seeing failures at high
volume, try a RESIDENTIAL proxy as an escalation, not a default.

### Related scrapers

- **Farfetch Scraper** — the largest luxury marketplace, with real per-size
  stock and a manufacturer style code.
- **Browns Fashion Scraper** — UK multi-brand luxury boutique on an open
  Shopify feed.
- **Mytheresa Scraper** — curated luxury with a size ladder.
- **ASOS Scraper** — mass-market UK multi-brand fashion.

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

# Actor input Schema

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

Brand names to scrape, e.g. 'Nike', 'Stone Island'. Resolved to the brand's page on END. Note: a handful of brand slugs on END. don't follow a naive lowercase-dash pattern (e.g. 'C.P. Company' -> 'cp-company') — if a brand returns nothing, use categoryUrls with the exact slug from the site instead.

## `categoryUrls` (type: `array`):

Category paths, e.g. 'footwear/boots', 'clothing', 'accessories/bags', 'sale/all-sale', 'new-in', or a full endclothing.com URL. See endclothing.com's own navigation for valid paths.

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

Direct product page URLs to scrape, skipping brand/category listing discovery entirely.

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

Which END. storefront to read. Prices and currency follow the country's own storefront.

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

Maximum number of products to return. Each brand/category page lists up to 120 products with no server-side pagination past that — combine several brands/categories to reach more.

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

Parallel product-page requests.

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

END.'s product and category HTML pages are not behind an anti-bot wall (verified live with a plain request, no proxy) — automatic Apify Proxy is enough for normal use. Only the site's internal REST/search API is gated, and this actor never calls it.

## Actor input object example

```json
{
  "brands": [
    "Nike"
  ],
  "country": "gb",
  "maxItems": 20,
  "concurrency": 5,
  "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 = {
    "brands": [
        "Nike"
    ],
    "country": "gb",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/endclothing-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 = {
    "brands": ["Nike"],
    "country": "gb",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/endclothing-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 '{
  "brands": [
    "Nike"
  ],
  "country": "gb",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/endclothing-scraper --silent --output-dataset

```

## MCP server setup

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