# Gymshark Scraper (`crawlerbros/gymshark-scraper`) Actor

Scrape Gymshark's activewear catalog - browse by category, keyword search, or fetch full product detail by URL. Prices, sale prices, colours, sizes, stock status, ratings, reviews, and images, with no login required.

- **URL**: https://apify.com/crawlerbros/gymshark-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Gymshark Scraper

Scrape [Gymshark](https://www.gymshark.com) — leggings, hoodies, sports bras, shorts, and the rest of the Gymshark activewear catalog. Browse by category, run a keyword search across the full catalog, or fetch full product detail (description, colour variants, size stock, and sample customer reviews) for specific product URLs. Real prices, sale prices, colours, sizes, and ratings — no login, cookies, or paid proxy required.

### What this actor does

- **Three modes:** `byCategory`, `search`, `byProduct`
- **40 curated categories** (leggings, shorts, sports bras, hoodies, joggers, tanks, seamless, swimwear, and more) as a dropdown, plus a free-text `customCategorySlug` override for any of Gymshark's other collection slugs
- **Men's / Women's** department filter
- **Live pricing:** current price, "was" price when discounted, computed discount %
- **Rich filters:** price range, sale-only, new-arrivals-only, in-stock-only, colour, size, fit, activity (lifting/HIIT/running/etc.), minimum customer rating
- **Sort:** best match, price low→high, price high→low, rating high→low
- **Product detail mode** adds: full description, colour variants with their own price/stock, a sample of the newest customer reviews, and an aggregate review breakdown (recommend %, star-rating distribution)
- **Empty fields are omitted** — every record only contains data Gymshark actually returned

### Output per product

| Field | Description |
|---|---|
| `productId` | Gymshark internal product ID |
| `sku` | Style SKU |
| `title` | Product name |
| `colourName`, `canonicalColour` | Colourway name and its normalized colour family |
| `gender` | `mens` / `womens` / `unisex` |
| `category`, `productType` | Category (e.g. `full length`) and full taxonomy path (e.g. `Womens>Apparel>Leggings>full_length`) |
| `fit`, `garmentRise`, `garmentLength` | Fit/cut details |
| `price` | Current price (USD) |
| `compareAtPrice` | Pre-discount price, only present when on sale |
| `discountPercentage` | Computed % off, only present when on sale |
| `onSale` | `true` if currently discounted |
| `lowestPrice` | Lowest price seen in the last 30 days (Gymshark's own field) |
| `inStock` | `true` if any size is currently in stock |
| `availableSizes` | Array of in-stock sizes |
| `rating`, `reviewCount` | Average customer rating (1–5) and review count |
| `activities`, `features` | Activity tags (e.g. `lifting`) and fabric/design features (e.g. `seamless`, `bum-scrunch`) |
| `tags` | Merchandising collection tags the product belongs to |
| `labels` | Gymshark's own merchandising badges shown on the product card (e.g. `new`, `sale`) |
| `promotionalMessaging` | Short marketing blurb Gymshark shows on the product card (e.g. `"100% cotton"`, `"new & improved"`), when present |
| `imageUrl`, `imageUrls` | Primary image and up to 12 gallery images |
| `availableColours` | Other colourways of the same style, each with its own product URL and image |
| `handle`, `productUrl`, `sourceUrl` | Canonical Gymshark product page |
| `description` | Full product description (mode=`byProduct` only) |
| `range`, `season`, `division`, `subcategory`, `segmentation` | Gymshark's internal merchandising taxonomy (mode=`byProduct` only) |
| `sizeGuide`, `braSupport` | Sizing/support metadata where applicable (mode=`byProduct` only) |
| `isNewRelease`, `willRestock` | Product lifecycle flags (mode=`byProduct` only) |
| `variants` | Other colourways with their own price/stock/image (mode=`byProduct` only) |
| `topReviews` | Sample of the newest customer reviews — rating, title, text, username, date (mode=`byProduct` only) |
| `reviewBreakdown` | Aggregate review stats — `recommendedPercentage`, `recommendedCount`, `notRecommendedCount`, and `ratingDistribution` (count per 1–5 star value) (mode=`byProduct` only) |
| `recordType` | Always `"product"` |
| `scrapedAt` | UTC ISO timestamp |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `byCategory` | `byCategory` / `search` / `byProduct` |
| `category` | select | `leggings` | Category slug (mode=`byCategory`) |
| `customCategorySlug` | string | – | Override `category` with any gymshark.com collection slug |
| `gender` | select | – | `mens` / `womens` — leave unset to cover both |
| `searchQuery` | string | `leggings` | Keyword matched against title/category/colour/tags (mode=`search`) |
| `productUrls` | array | – | Full product URLs or bare handles (mode=`byProduct`) |
| `sortBy` | select | `relevance` | `relevance` / `priceLowToHigh` / `priceHighToLow` / `ratingHighToLow` |
| `minPrice` / `maxPrice` | integer | – | Price range filter (USD) |
| `onSaleOnly` | boolean | `false` | Only emit discounted products |
| `newOnly` | boolean | `false` | Only emit products carrying Gymshark's "New" merchandising badge |
| `inStockOnly` | boolean | `false` | Only emit products with at least one size in stock |
| `colour` | select | – | Colour filter (12 canonical colours) |
| `size` | select | – | Only emit products with this size in stock |
| `fit` | select | – | Fit filter (14 options) |
| `activity` | select | – | Activity filter (conditioning/HIIT/hybrid/lifting/rest day/running/studio) |
| `minRating` | integer | – | Drop products rated below this (1–5) |
| `maxReviewsPerProduct` | integer | `5` | Sample reviews to include per product (mode=`byProduct`, 0–20) |
| `maxItems` | integer | `60` | Hard cap on emitted records (1–5000) |
| `proxyConfiguration` | object | AUTO | Apify proxy config; the free AUTO datacenter group is used automatically as a fallback if a run is rate-limited — no paid proxy is required |

#### Example: browse women's leggings on sale, sorted by price

```json
{
  "mode": "byCategory",
  "category": "leggings",
  "gender": "womens",
  "onSaleOnly": true,
  "sortBy": "priceLowToHigh",
  "maxItems": 40
}
````

#### Example: keyword search

```json
{ "mode": "search", "searchQuery": "seamless", "gender": "womens", "maxItems": 30 }
```

#### Example: fetch full detail for specific products

```json
{
  "mode": "byProduct",
  "productUrls": [
    "https://www.gymshark.com/products/gymshark-whitney-flared-leggings-leggings-pink-ss26"
  ],
  "maxReviewsPerProduct": 10
}
```

### Use cases

- **Price monitoring** — track sale prices and discount % across drops
- **Assortment / catalog research** — pull a category's full live Gymshark range
- **Review & rating analysis** — pull `rating`/`reviewCount`/`topReviews` for sentiment or quality research
- **Competitor / market intelligence** — benchmark pricing and assortment against other activewear retailers
- **Deal aggregation** — feed `onSaleOnly` results into a deals feed

### Data source & limitations

Data comes directly from Gymshark's server-rendered storefront (`gymshark.com`) — no login, cookies, or paid proxy required. Every `/collections/<slug>[/<gender>]` and `/products/<handle>` page embeds a full JSON payload (an Algolia search response for collections, a complete product document for detail pages) directly in the page HTML.

- **`search` mode** scans the full "all products" catalog (~700 products per department) page by page and matches your keyword against title, category, colour, and tags — it is not Gymshark's own live-typeahead search (that endpoint is only reachable from a JS-hydrated browser session), but it covers the same catalog.
- **Sort options** are applied after fetching, not passed through to Gymshark's own (JS-only) sort widget — the underlying data is identical either way.
- **Currency** is always USD (gymshark.com's default US storefront).
- Some very small or seasonal/out-of-stock collections may return 0 products at any given time — this reflects Gymshark's live catalog, not a scraping error.

#### About this actor

This actor was built after determining that lululemon.com — the originally planned target for this activewear-catalog slot — rejects all connection attempts from Apify's cloud infrastructure at the network/TLS level (`net::ERR_HTTP2_PROTOCOL_ERROR` from a real headless browser, with and without Apify's free datacenter proxy; `400 Bad Request` from AWS WAF Bot Control on TLS-impersonated requests; `403 Access Denied` from Akamai on plain HTTP). Since the project only ships actors that work on Apify's free plan without paid residential proxy, Gymshark — a comparable activewear retailer that is fully and reliably reachable from Apify's free datacenter IPs — was built in its place.

### FAQ

**Do I need a Gymshark account or cookies?**  No — every field is publicly visible without logging in.

**Why do some products have no `compareAtPrice`?**  Only currently-discounted products carry a `compareAtPrice`; full-price products only have `price`.

**What does `lowestPrice` mean?**  It's Gymshark's own "lowest price in the last 30 days" figure, shown for price-transparency compliance in some markets.

**Can I get every colourway of a product?**  Yes — every record includes `availableColours` (listing) or `variants` (detail mode), each with its own product URL and image.

**How current is the data?**  Live — every run fetches the current Gymshark site directly; there is no caching layer.

# Actor input Schema

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

What to fetch: browse a category collection, keyword search across the catalog, or fetch specific product URLs.

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

Product category to browse. Combine with `gender` below. Use `customCategorySlug` instead to target any of Gymshark's other collection slugs (e.g. seasonal drops) not listed here.

## `customCategorySlug` (type: `string`):

Any gymshark.com/collections/<slug> value not covered by the `category` dropdown (e.g. `whitney`, `flared-leggings`, `black-leggings`). Takes precedence over `category` when set.

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

Scopes `byCategory` and `search` to one department. Leave unset to browse/search both.

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

Keyword matched case-insensitively against product title, category, colour, and merchandising tags across the full catalog (~700 products per department).

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

Full gymshark.com/products/<handle> URLs, or bare handles, e.g. `gymshark-whitney-flared-leggings-leggings-pink-ss26`.

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

Sort order applied to results after fetching (byCategory/search modes).

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

Drop products priced below this (current price).

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

Drop products priced above this (current price).

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

Only emit products currently discounted.

## `newOnly` (type: `boolean`):

Only emit products currently carrying Gymshark's own "New" merchandising badge.

## `inStockOnly` (type: `boolean`):

Only emit products with at least one size currently in stock.

## `colour` (type: `string`):

Only emit products of this canonical colour.

## `size` (type: `string`):

Only emit products with this size currently in stock.

## `fit` (type: `string`):

Only emit products with this fit.

## `activity` (type: `string`):

Only emit products tagged for this activity.

## `minRating` (type: `integer`):

Drop products with an average rating below this (1-5 stars).

## `maxReviewsPerProduct` (type: `integer`):

Number of sample customer reviews to include per product detail record.

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

Hard cap on emitted records.

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

Gymshark's collection and product pages are reachable directly from Apify datacenter IPs; the free AUTO proxy group is used automatically as a fallback if a run hits rate limiting. No paid proxy group is required.

## Actor input object example

```json
{
  "mode": "byCategory",
  "category": "leggings",
  "searchQuery": "leggings",
  "productUrls": [
    "https://www.gymshark.com/products/gymshark-whitney-flared-leggings-leggings-pink-ss26"
  ],
  "sortBy": "relevance",
  "onSaleOnly": false,
  "newOnly": false,
  "inStockOnly": false,
  "maxReviewsPerProduct": 5,
  "maxItems": 60,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Gymshark 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": "byCategory",
    "category": "leggings",
    "searchQuery": "leggings",
    "productUrls": [
        "https://www.gymshark.com/products/gymshark-whitney-flared-leggings-leggings-pink-ss26"
    ],
    "sortBy": "relevance",
    "onSaleOnly": false,
    "newOnly": false,
    "inStockOnly": false,
    "maxReviewsPerProduct": 5,
    "maxItems": 60,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/gymshark-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 = {
    "mode": "byCategory",
    "category": "leggings",
    "searchQuery": "leggings",
    "productUrls": ["https://www.gymshark.com/products/gymshark-whitney-flared-leggings-leggings-pink-ss26"],
    "sortBy": "relevance",
    "onSaleOnly": False,
    "newOnly": False,
    "inStockOnly": False,
    "maxReviewsPerProduct": 5,
    "maxItems": 60,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/gymshark-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 '{
  "mode": "byCategory",
  "category": "leggings",
  "searchQuery": "leggings",
  "productUrls": [
    "https://www.gymshark.com/products/gymshark-whitney-flared-leggings-leggings-pink-ss26"
  ],
  "sortBy": "relevance",
  "onSaleOnly": false,
  "newOnly": false,
  "inStockOnly": false,
  "maxReviewsPerProduct": 5,
  "maxItems": 60,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/gymshark-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gymshark Scraper",
        "description": "Scrape Gymshark's activewear catalog - browse by category, keyword search, or fetch full product detail by URL. Prices, sale prices, colours, sizes, stock status, ratings, reviews, and images, with no login required.",
        "version": "1.0",
        "x-build-id": "r7omZqtzL3c9goont"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~gymshark-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-gymshark-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~gymshark-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-gymshark-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~gymshark-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-gymshark-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byCategory",
                            "search",
                            "byProduct"
                        ],
                        "type": "string",
                        "description": "What to fetch: browse a category collection, keyword search across the catalog, or fetch specific product URLs.",
                        "default": "byCategory"
                    },
                    "category": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "all-products",
                            "accessories",
                            "athleisure",
                            "bags",
                            "base-layers",
                            "bodybuilding",
                            "bottoms",
                            "crop-tops",
                            "flex",
                            "headwear",
                            "hoodies",
                            "hoodies-jackets",
                            "jackets",
                            "joggers",
                            "joggers-sweatpants",
                            "leggings",
                            "legacy",
                            "long-sleeve",
                            "matching-sets",
                            "new-releases",
                            "outlet",
                            "oversized",
                            "pullovers",
                            "running",
                            "seamless",
                            "seamless-leggings",
                            "shorts",
                            "sleeveless",
                            "socks",
                            "sports-bras",
                            "stringers",
                            "swimwear",
                            "t-shirts-tops",
                            "tanks",
                            "tracksuits",
                            "underwear",
                            "vests",
                            "yoga",
                            "zip-hoodies",
                            "zip-jackets"
                        ],
                        "type": "string",
                        "description": "Product category to browse. Combine with `gender` below. Use `customCategorySlug` instead to target any of Gymshark's other collection slugs (e.g. seasonal drops) not listed here.",
                        "default": "leggings"
                    },
                    "customCategorySlug": {
                        "title": "Custom category slug (overrides `category`)",
                        "type": "string",
                        "description": "Any gymshark.com/collections/<slug> value not covered by the `category` dropdown (e.g. `whitney`, `flared-leggings`, `black-leggings`). Takes precedence over `category` when set."
                    },
                    "gender": {
                        "title": "Gender",
                        "enum": [
                            "mens",
                            "womens"
                        ],
                        "type": "string",
                        "description": "Scopes `byCategory` and `search` to one department. Leave unset to browse/search both."
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Keyword matched case-insensitively against product title, category, colour, and merchandising tags across the full catalog (~700 products per department).",
                        "default": "leggings"
                    },
                    "productUrls": {
                        "title": "Product URLs (mode=byProduct)",
                        "type": "array",
                        "description": "Full gymshark.com/products/<handle> URLs, or bare handles, e.g. `gymshark-whitney-flared-leggings-leggings-pink-ss26`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "priceLowToHigh",
                            "priceHighToLow",
                            "ratingHighToLow"
                        ],
                        "type": "string",
                        "description": "Sort order applied to results after fetching (byCategory/search modes).",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Min price (USD)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Drop products priced below this (current price)."
                    },
                    "maxPrice": {
                        "title": "Max price (USD)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Drop products priced above this (current price)."
                    },
                    "onSaleOnly": {
                        "title": "Sale items only",
                        "type": "boolean",
                        "description": "Only emit products currently discounted.",
                        "default": false
                    },
                    "newOnly": {
                        "title": "New arrivals only",
                        "type": "boolean",
                        "description": "Only emit products currently carrying Gymshark's own \"New\" merchandising badge.",
                        "default": false
                    },
                    "inStockOnly": {
                        "title": "In-stock only",
                        "type": "boolean",
                        "description": "Only emit products with at least one size currently in stock.",
                        "default": false
                    },
                    "colour": {
                        "title": "Colour filter",
                        "enum": [
                            "black",
                            "blue",
                            "brown",
                            "green",
                            "grey",
                            "orange",
                            "pink",
                            "purple",
                            "red",
                            "teal",
                            "white",
                            "yellow"
                        ],
                        "type": "string",
                        "description": "Only emit products of this canonical colour."
                    },
                    "size": {
                        "title": "Size filter",
                        "enum": [
                            "xxs",
                            "xs",
                            "s",
                            "s/m",
                            "m",
                            "m/l",
                            "l",
                            "xl",
                            "xxl",
                            "3xl",
                            "one-size"
                        ],
                        "type": "string",
                        "description": "Only emit products with this size currently in stock."
                    },
                    "fit": {
                        "title": "Fit filter",
                        "enum": [
                            "regular",
                            "regular fit",
                            "slim fit",
                            "muscle fit",
                            "oversized",
                            "oversized fit",
                            "boxy fit",
                            "body fit",
                            "compression fit",
                            "high support",
                            "medium support",
                            "light support",
                            "tall",
                            "short"
                        ],
                        "type": "string",
                        "description": "Only emit products with this fit."
                    },
                    "activity": {
                        "title": "Activity filter",
                        "enum": [
                            "conditioning",
                            "hiit",
                            "hybrid",
                            "lifting",
                            "rest day",
                            "running",
                            "studio"
                        ],
                        "type": "string",
                        "description": "Only emit products tagged for this activity."
                    },
                    "minRating": {
                        "title": "Min customer rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop products with an average rating below this (1-5 stars)."
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product (mode=byProduct)",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of sample customer reviews to include per product detail record.",
                        "default": 5
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 60
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Gymshark's collection and product pages are reachable directly from Apify datacenter IPs; the free AUTO proxy group is used automatically as a fallback if a run hits rate limiting. No paid proxy group is required.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
