# Skechers Scraper (`crawlerbros/skechers-scraper`) Actor

Scrape Skechers.com - search products, browse 50+ shoe/clothing categories by gender and type, or look up exact products by style ID. Get price, sale/original price, color, gender, category, images, and PowerReviews ratings. No auth, no proxy required.

- **URL**: https://apify.com/crawlerbros/skechers-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **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 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

## Skechers Scraper

Scrape Skechers.com — search products, browse 50+ shoe and clothing categories by gender and type, or look up exact products by style ID. Get price, original/sale price, color, gender, category, images, and PowerReviews ratings. HTTP-only against the public `skechers.com` storefront. No auth, no login, no proxy required.

### What this actor does

- **Three modes:** `search`, `byCategory`, `byProductId`
- **50+ curated categories** covering men's / women's / kids' shoes by type (sneakers, boots, sandals, slip-ons, work & safety, wide fit, …) plus clothing & accessories and a dedicated Sale/Clearance collection — with a `customCategoryId` override for anything not in the list
- **Filters:** gender, price range, on-sale-only, width, color family, comfort technology, style/shape, comfort collection, comfort feature, apparel style, US shoe size, kids age group (last nine: mode=byCategory only)
- **Sort orders:** best matches, newest, top sellers, price high-to-low, price low-to-high, percent off (biggest discounts)
- **Ratings enrichment** — average rating + review count from the public PowerReviews widget (mode=byProductId)
- **Empty fields are omitted**

### Output per product

- `productId` — Skechers style ID (e.g. `177197`)
- `colorId`, `sku` — color code and full style+color SKU (e.g. `177197_NVY`)
- `name`, `description` (mode=byProductId only — full PDP fetch)
- `brand`, `brandTags[]`
- `gender` — `Men` / `Women` / `Boys` / `Girls` / `Unisex`
- `category` — upstream taxonomy path, e.g. `Women/Shoes/Slip-Ons`
- `collection` — Skechers' internal product line/marketing collection label, e.g. `SPORT WOMENS`, `BOBS WOMENS`, `USA MENS`
- `color`, `colorDescription`
- `price`, `originalPrice`, `currency`, `onSale`, `discountAmount`
- `priceMax` (mode=byProductId only) — present when the style's price varies by size (Skechers exposes it as a price range rather than a single price); `price` is the range's starting/lowest price
- `inStock` (mode=byProductId only — live PDP availability)
- `ageGroup` (mode=byProductId only)
- `imageUrl`, `images[]` (mode=byProductId only)
- `availableColors[]` — `{colorId, colorName}` for every color this style is offered in (mode=byProductId only)
- `availableWidths[]` — e.g. `Medium`, `Wide`, `Extra Wide` — only present for styles that offer width variants (mode=byProductId only)
- `availableSizes[]` — `{size, inStock}` for every size offered in the fetched color (mode=byProductId only)
- `keyFeatures[]` — bullet list from the PDP's "Key Features" section, e.g. `Skechers Air-Cooled Memory Foam® insole` (mode=byProductId only)
- `designDetails[]` — bullet list from the PDP's "Design Details" section, e.g. `Synthetic and textile upper` (mode=byProductId only)
- `averageRating`, `reviewCount` (mode=byProductId, when `includeRatings=true`)
- `productUrl`
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `byProductId` |
| `searchQuery` | string | `slip on sneakers` | Free-text query (mode=search) |
| `category` | string | `womenShoesAthleticSneakers` | Curated category (mode=byCategory) |
| `customCategoryId` | string | – | Raw category id override |
| `productIds` | array | `["177197"]` | Style IDs / SKUs / URLs (mode=byProductId) |
| `gender` | string | – | `Men` / `Women` / `Boys` / `Girls` |
| `sortBy` | string | `bestMatches` | `bestMatches` / `newest` / `topSellers` / `priceHighToLow` / `priceLowToHigh` / `percentOff` |
| `minPrice` / `maxPrice` | int | – | USD price bounds |
| `width` | string | – | `Medium` / `Wide` / `Extra Wide` (mode=byCategory only) |
| `colorFamily` | string | – | One of 12 swatch color families, e.g. `Black`, `Navy` (mode=byCategory only) |
| `technology` | string | – | Comfort/cushioning tech, e.g. `Arch Fit`, `Hyper Burst` (mode=byCategory only) |
| `style` | string | – | Shoe shape/style, e.g. `Sneaker`, `Boot`, `Sandal` (mode=byCategory only) |
| `comfortCollection` | string | – | Named Skechers product line, e.g. `BOBS`, `GO WALK` (mode=byCategory only) |
| `comfortFeature` | string | – | Construction/care feature, e.g. `Waterproof`, `Vegan` (mode=byCategory only) |
| `apparelStyle` | string | – | Apparel style/cut, e.g. `Hoodies`, `Leggings` (mode=byCategory, `clothing*` categories only) |
| `productLine` | string | – | `FOOTWEAR` / `APPAREL` / `ACCESSORIES` / `BAGS` — most useful on mixed categories like `men`/`women`/`kids`/`sale` (mode=byCategory only) |
| `occasion` | string | – | Occasion/use-case, e.g. `Athletic`, `Dress`, `Work` (mode=byCategory only) |
| `size` | number | – | US shoe size, e.g. `8`, `8.5` — all age groups (mode=byCategory only) |
| `kidsAgeGroup` | string | – | `toddlers` / `littleKids` / `bigKids` — kids' age/size bucket (mode=byCategory only) |
| `onSaleOnly` | bool | `false` | Only discounted products |
| `includeRatings` | bool | `true` | Fetch PowerReviews rating (mode=byProductId) |
| `maxItems` | int | `24` | Hard cap (1–500) |
| `proxyConfiguration` | object | off | Optional automatic fallback if Skechers starts blocking requests |

#### Example: browse a category

```json
{
  "mode": "byCategory",
  "category": "menShoesAthleticSneakers",
  "gender": "Men",
  "sortBy": "topSellers",
  "maxItems": 48
}
```

#### Example: search with price filter

```json
{
  "mode": "search",
  "searchQuery": "hiking boots",
  "minPrice": 50,
  "maxPrice": 120,
  "maxItems": 30
}
```

#### Example: lookup exact products with ratings

```json
{
  "mode": "byProductId",
  "productIds": ["177197", "11933_WSL", "https://www.skechers.com/dlites---bright-sky/11931EW_WSL.html"],
  "includeRatings": true
}
```

### Use cases

- **Price monitoring** — track sale prices and discount amounts across categories
- **Catalog enrichment** — pull structured product data (color, gender, category) for a PIM or comparison site
- **Competitive intelligence** — benchmark footwear pricing and assortment by category
- **Review analytics** — combine PowerReviews rating data with product metadata
- **Affiliate content** — build category landing pages with live pricing and images

### FAQ

**Do I need a proxy or login?**  No. The actor reads Skechers' public storefront directly. A proxy field is exposed only as an automatic fallback if the site ever starts blocking requests.

**What's the difference between `search` and `byCategory`?**  `search` matches Skechers' own search index (fuzzy, relevance-ranked); `byCategory` walks a fixed taxonomy node and returns everything in it — better for exhaustive category dumps.

**What if the category I want isn't in the dropdown?**  Set `customCategoryId` to the raw category id (`cgid`) — visible in any skechers.com category page URL's `cgid=` query parameter.

**Why does `inStock` only appear in `byProductId` mode?**  Skechers' search/category grid pages don't carry live per-color inventory in their server-rendered HTML (it's resolved client-side). Product-detail pages do expose real inventory via structured data, so `byProductId` is the reliable source for stock status.

**What accepted product ID formats work for `productIds`?**  A bare style ID (`177197`), a style+color SKU (`177197_NVY`), or a full product URL — the actor auto-detects the format.

**How is `averageRating` sourced?**  From Skechers' public PowerReviews widget API (the same one that powers the on-page star rating), keyed by style ID.

**Why do some products have `priceMax` and others don't?**  A minority of styles price by size (e.g. kids' vs. adult sizing under the same style) and Skechers publishes those as a price range (`AggregateOffer`) instead of a single price. For those, `price` is the range's low end and `priceMax` is the high end; most styles have one flat price and never get `priceMax`.

**How are `availableColors` / `availableWidths` sourced?**  Directly from the color-swatch and width-selector buttons rendered server-side in the product-detail page HTML — no extra request needed. `availableWidths` only appears on styles that actually offer a width choice (most styles are Medium-only, so the field is simply omitted for them).

**How is `availableSizes` sourced?**  Directly from the size-selector buttons rendered server-side on the product-detail page for the fetched color — no extra request needed. A size whose button is marked unselectable (its variation URL is `null`) is sold out in that color and gets `inStock: false`; every other listed size gets `inStock: true`. This reflects stock for the color the `productIds` entry resolved to (e.g. `177197_NVY`) — pass a specific style+color SKU to check a particular color's sizes.

**Why do `width` / `colorFamily` / `technology` / `style` / `comfortCollection` / `comfortFeature` / `occasion` / `size` only work with `mode=byCategory`?**  These are Skechers' own faceted-navigation filters (`prefn`/`prefv` query params on the category grid endpoint) — confirmed live they narrow results only against `cgid=` category browsing, not the `q=` free-text search index, which silently returns zero tiles if you pass them there. Combine them with `category`/`customCategoryId` to use them.

**What are `style`, `comfortCollection`, and `comfortFeature`?**  Skechers' own product-shape (`Sneaker`, `Boot`, `Sandal`, …), named product-line (`BOBS`, `GO WALK`, `Arch Fit`-adjacent collections, …), and construction/care (`Waterproof`, `Vegan`, `Machine Washable`, …) refinement facets, confirmed live against the category grid. Not every value is offered by every category — an unsupported combination correctly returns 0 rather than a wrong match.

**Does `size` work for Kids categories too?**  Yes — it matches each category's own real offered size range (adult, Big Kids, or Toddler numbering), not just adult sizing. A value outside what that specific category actually offers (e.g. size `20`, or an adult size on a toddler-only category) correctly returns 0 rather than a wrong match.

**What does `kidsAgeGroup` do, and how is it different from `size`?**  It's Skechers' own age/size-bucket facet (`toddlers` = Sizes 5-10, `littleKids` = Sizes 10.5-3, `bigKids` = Sizes 3.5-7) — useful when you want "everything in the Big Kids range" without knowing exact sizes. It only narrows kids categories; applied to a non-kids category it correctly returns 0 rather than a wrong match. Little Kids and Big Kids buckets overlap by design at their shared boundary sizes (Skechers' own bucketing, not a bug).

**How are `keyFeatures` / `designDetails` sourced?**  Directly from the two bullet-list sections rendered server-side on every product-detail page — no extra request needed. `keyFeatures` covers comfort/technology callouts (e.g. cushioning system, fit type); `designDetails` covers construction/material specifics (e.g. upper material, heel height). Both are omitted only in the rare case a style's PDP renders neither section.

**How is `collection` sourced?**  From Skechers' own internal product-line/marketing-collection label (e.g. `SPORT WOMENS`, `BOBS WOMENS`, `USA MENS`) embedded server-side in every listing tile and product-detail page — no extra request needed, present in all three modes.

# Actor input Schema

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

What to fetch.

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

Free-text query (mode=search), e.g. `slip on sneakers` or `hiking boots`.

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

Pick a curated Skechers category. For a category not listed, use `customCategoryId` instead.

## `customCategoryId` (type: `string`):

Overrides `category` with any raw Skechers category id (`cgid`) — find it in a skechers.com category page URL's `cgid=` query param. Use when the category you want isn't in the curated dropdown.

## `productIds` (type: `array`):

Skechers style IDs (`177197`), style+color SKUs (`177197_NVY`), or full product URLs.

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

Only emit products matching this gender/age group. Leave blank for no filter.

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

Result ordering (search / browse by category).

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

Drop products cheaper than this.

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

Drop products pricier than this.

## `width` (type: `string`):

Only emit products offered in this width. Applies to `byCategory` only — Skechers' free-text search index doesn't support this facet.

## `colorFamily` (type: `string`):

Only emit products in this swatch color family. Applies to `byCategory` only — Skechers' free-text search index doesn't support this facet.

## `technology` (type: `string`):

Only emit products featuring this comfort/cushioning technology. Applies to `byCategory` only — Skechers' free-text search index doesn't support this facet.

## `style` (type: `string`):

Only emit products of this shoe shape/style. Applies to `byCategory` only — Skechers' free-text search index doesn't support this facet.

## `comfortCollection` (type: `string`):

Only emit products from this named Skechers product line/collection. Applies to `byCategory` only — Skechers' free-text search index doesn't support this facet.

## `comfortFeature` (type: `string`):

Only emit products with this construction/care feature. Applies to `byCategory` only — Skechers' free-text search index doesn't support this facet.

## `apparelStyle` (type: `string`):

Only emit products of this apparel style/cut. Applies to the `clothing*` categories only (e.g. `clothingWomensTops`, `clothingMensBottoms`) — has no effect (0 results) on shoe categories.

## `productLine` (type: `string`):

Only emit products of this top-level product type. Most useful on mixed categories that interleave footwear/apparel/accessories/bags (`men`, `women`, `kids`, `sale`, `clothingAccessories`) — has no effect (0 results) on already single-type categories, e.g. `APPAREL` on a pure shoe category. Applies to `byCategory` only.

## `occasion` (type: `string`):

Only emit products tagged for this occasion/use-case. Applies to `byCategory` only — Skechers' free-text search index doesn't support this facet. Not every value is offered by every category — an unsupported combination correctly returns 0 rather than a wrong match.

## `size` (type: `number`):

Only emit products available in this US shoe size (e.g. `8`, `8.5` — enter half sizes like `8.5`). Applies to `byCategory` only. Works across all age groups (Men/Women/Kids/Toddler) using each category's own real size range — a value outside what that category actually offers (e.g. an adult size in a toddler category) correctly returns 0 rather than a wrong match.

## `kidsAgeGroup` (type: `string`):

Only emit kids' products in this Skechers age/size bucket. Applies to `byCategory` only — Skechers' free-text search index doesn't support this facet. Has no effect (0 results) on non-kids categories.

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

Only emit products currently discounted below their original price.

## `includeRatings` (type: `boolean`):

Fetch average rating + review count from the public PowerReviews widget for each product ID. Adds one extra request per item.

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

Hard cap on emitted records.

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

Optional. The actor works without a proxy; this is only used as an automatic fallback if Skechers starts blocking requests (403/429).

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "slip on sneakers",
  "category": "womenShoesAthleticSneakers",
  "productIds": [
    "177197"
  ],
  "gender": "",
  "sortBy": "bestMatches",
  "width": "",
  "colorFamily": "",
  "technology": "",
  "style": "",
  "comfortCollection": "",
  "comfortFeature": "",
  "apparelStyle": "",
  "productLine": "",
  "occasion": "",
  "kidsAgeGroup": "",
  "onSaleOnly": false,
  "includeRatings": true,
  "maxItems": 24,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Skechers 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": "search",
    "searchQuery": "slip on sneakers",
    "category": "womenShoesAthleticSneakers",
    "productIds": [
        "177197"
    ],
    "gender": "",
    "sortBy": "bestMatches",
    "width": "",
    "colorFamily": "",
    "technology": "",
    "style": "",
    "comfortCollection": "",
    "comfortFeature": "",
    "apparelStyle": "",
    "productLine": "",
    "occasion": "",
    "kidsAgeGroup": "",
    "onSaleOnly": false,
    "includeRatings": true,
    "maxItems": 24
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/skechers-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": "search",
    "searchQuery": "slip on sneakers",
    "category": "womenShoesAthleticSneakers",
    "productIds": ["177197"],
    "gender": "",
    "sortBy": "bestMatches",
    "width": "",
    "colorFamily": "",
    "technology": "",
    "style": "",
    "comfortCollection": "",
    "comfortFeature": "",
    "apparelStyle": "",
    "productLine": "",
    "occasion": "",
    "kidsAgeGroup": "",
    "onSaleOnly": False,
    "includeRatings": True,
    "maxItems": 24,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/skechers-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 '{
  "mode": "search",
  "searchQuery": "slip on sneakers",
  "category": "womenShoesAthleticSneakers",
  "productIds": [
    "177197"
  ],
  "gender": "",
  "sortBy": "bestMatches",
  "width": "",
  "colorFamily": "",
  "technology": "",
  "style": "",
  "comfortCollection": "",
  "comfortFeature": "",
  "apparelStyle": "",
  "productLine": "",
  "occasion": "",
  "kidsAgeGroup": "",
  "onSaleOnly": false,
  "includeRatings": true,
  "maxItems": 24
}' |
apify call crawlerbros/skechers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlerbros/skechers-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/94d1d6oUxEqkviVfW/builds/ChAAGQJREq1es6e0u/openapi.json