# Helly Hansen Scraper — Outdoor & Sailing Apparel Prices (`studio-amba/hellyhansen-scraper`) Actor

Scrape outdoor and sailing apparel from HellyHansen.com. Get product details, pricing, sizes, and technical specs from their Magento-based store.

- **URL**: https://apify.com/studio-amba/hellyhansen-scraper.md
- **Developed by:** [Jelle Desramaults](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Helly Hansen Scraper -- Norwegian Outdoor & Sailing Apparel Data

Scrape product data from HellyHansen.com -- the legendary Norwegian brand trusted by sailors, skiers, and outdoor professionals since 1877. Extract prices, technical specs, ratings, and availability from their complete catalog of waterproof jackets, sailing gear, base layers, and ski apparel.

### What is Helly Hansen Scraper?

Helly Hansen (HH) is a Norwegian performance brand rooted in professional-grade protection against the elements. Their product line spans sailing gear (offshore jackets, trousers, boots), ski apparel, hiking clothing, urban rainwear, and workwear. From a EUR 50 base layer to a EUR 900 offshore sailing jacket, this scraper gives you structured access to their catalog.

Who needs this data:

- **Sailing & marine gear monitoring** -- Helly Hansen is a dominant brand in competitive sailing. Track pricing on their AEGIR, Newport, and Skagen Pro lines. Know when offshore gear goes on sale before race season.
- **Ski apparel price tracking** -- HH supplies ski teams worldwide. Monitor their ski jackets, insulated pants, and base layers for seasonal markdowns and new model launches.
- **Outdoor brand competitive analysis** -- If you sell outdoor apparel (Patagonia, Arc'teryx, The North Face), Helly Hansen is a direct competitor. Track their pricing, catalog depth, and promotional calendar.
- **Technical spec comparison** -- HH provides detailed technical specs (waterproof ratings, breathability, HELLY TECH membrane types). Scrape specs for gear comparison databases.
- **Affiliate marketing & content** -- Build data-driven sailing gear guides, ski apparel round-ups, or deal alerts using structured product data with specs and pricing.

### What data does Helly Hansen Scraper extract?

- 🧥 **Product name** -- full product title
- 🏷️ **Brand** -- always "Helly Hansen"
- 💰 **Price** and currency
- 💸 **Original price** -- for sale items
- 🔢 **SKU and product ID**
- ✅ **Stock availability**
- ⭐ **Customer rating** and review count
- 🖼️ **Product images** -- primary and gallery
- 📝 **Description** -- product details and technology highlights
- 🔧 **Technical specs** -- waterproof rating, breathability, membrane type, weight
- 📂 **Category** and breadcrumb hierarchy

### How to scrape HellyHansen.com

#### Search for products

```json
{
    "searchQuery": "sailing jacket",
    "maxResults": 50
}
````

Good search terms: "sailing jacket", "ski pants", "base layer", "rain jacket", "offshore", "workwear".

#### Browse a category

Target a specific section of the HH catalog:

```json
{
    "categoryUrl": "https://www.hellyhansen.com/en_gb/men/jackets-and-coats",
    "maxResults": 100
}
```

Common category URLs:

- `/en_gb/men/jackets-and-coats` -- men's jackets
- `/en_gb/women/jackets-and-coats` -- women's jackets
- `/en_gb/sailing` -- sailing gear
- `/en_gb/ski` -- ski apparel
- `/en_gb/hiking` -- hiking clothing

#### Default behavior

If no search or category is provided, the scraper searches for all products.

**Note:** HellyHansen.com runs on Magento 2. The scraper handles Magento-style pagination automatically.

### Output

A typical Helly Hansen sailing jacket:

```json
{
    "name": "AEGIR Ocean Jacket",
    "brand": "Helly Hansen",
    "price": 650.00,
    "currency": "GBP",
    "url": "https://www.hellyhansen.com/en_gb/aegir-ocean-jacket-30335",
    "scrapedAt": "2025-04-03T15:00:00.000Z",
    "originalPrice": 750.00,
    "sku": "30335",
    "productId": "30335-598",
    "inStock": true,
    "rating": 4.7,
    "reviewCount": 43,
    "imageUrl": "https://www.hellyhansen.com/media/catalog/product/30335_598_main.jpg",
    "imageUrls": [
        "https://www.hellyhansen.com/media/catalog/product/30335_598_main.jpg",
        "https://www.hellyhansen.com/media/catalog/product/30335_598_back.jpg",
        "https://www.hellyhansen.com/media/catalog/product/30335_598_detail.jpg"
    ],
    "description": "The AEGIR Ocean Jacket is our most technically advanced offshore sailing jacket. Built with HELLY TECH Professional 3-layer construction, fully seam-sealed with Life Pocket insulation for your phone in extreme conditions.",
    "specs": {
        "Waterproofness": "Extremely waterproof (over 20,000mm)",
        "Breathability": "Highly breathable (over 15,000g/m2/24h)",
        "Membrane": "HELLY TECH Professional",
        "Weight": "850g (size L)",
        "Hood": "Adjustable, high-vis compatible"
    },
    "category": "Sailing Jackets",
    "categories": ["Men", "Sailing", "Jackets"]
}
```

### How much does it cost?

| Scenario | Estimated cost |
|----------|---------------|
| 50 products (search) | ~$0.03 |
| 200 products (category) | ~$0.10 |
| 500 products | ~$0.25 |
| Full catalog | ~$0.75+ |

Each product requires a detail page visit for complete data including specs and ratings. The scraper uses CheerioCrawler for efficient, browser-free extraction.

### Can I integrate?

Route Helly Hansen data where you need it:

- **Google Sheets** -- track sailing gear pricing in a spreadsheet
- **Webhooks** -- alerts when sailing jackets go on sale before race season
- **Zapier / Make** -- automate gear price monitoring
- **Slack** -- notifications for price drops on ski apparel
- **Amazon S3 / Google Cloud Storage** -- seasonal data archiving
- **Databases** -- power your outdoor gear comparison platform

### Can I use it as an API?

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/hellyhansen-scraper").call(run_input={
    "searchQuery": "ski jacket",
    "maxResults": 25,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    specs = item.get('specs', {})
    wp = specs.get('Waterproofness', '')
    print(f"{item['name']} -- {item['currency']} {item['price']} -- {wp}")
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('studio-amba/hellyhansen-scraper').call({
    searchQuery: 'ski jacket',
    maxResults: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    const wp = item.specs?.Waterproofness || '';
    console.log(`${item.name} -- ${item.currency} ${item.price} -- ${wp}`);
});
```

### FAQ

**Which Helly Hansen store does this target?**
The scraper targets the UK English store (en\_gb). This gives prices in GBP. Other regional stores (US, EU, Nordics) are not directly supported.

**Can I scrape sailing gear specifically?**
Yes. Use a sailing category URL like `https://www.hellyhansen.com/en_gb/sailing` or search for "sailing jacket", "offshore", or "regatta".

**Does it extract HELLY TECH membrane info?**
Yes, when available. Technical specs including waterproof ratings, breathability, and membrane type are extracted from product attribute tables on the detail page.

**How often does HH update prices?**
Helly Hansen typically runs two major sale periods (summer and winter). Mid-season promotions happen occasionally. Weekly or bi-weekly scraping captures most price changes.

**Are workwear products included?**
Yes. Helly Hansen's workwear line appears in search results and can be targeted via category URLs.

**Can I filter by activity (sailing, skiing, hiking)?**
Use activity-specific category URLs or search terms. The category field in the output also indicates the product's activity classification.

### Limitations

- The scraper targets hellyhansen.com/en\_gb (UK store). Other regional stores have different URLs and pricing.
- HellyHansen.com runs on Magento 2, which can be slow. Large scrapes may take proportionally longer than sites with APIs.
- Technical specs are extracted from HTML attribute tables. The available specs vary by product category and how completely HH has filled in product data.
- Some product listing pages use JavaScript rendering for product grids. The scraper handles this by looking for multiple link patterns including Magento-standard selectors.
- Product availability reflects online stock only.

### Other retail and fashion scrapers

Complete your outdoor and sports retail data set:

- [AS Adventure Scraper](https://apify.com/studio-amba/asadventure-scraper) -- Belgium's biggest outdoor retailer
- [Bergfreunde Scraper](https://apify.com/studio-amba/bergfreunde-scraper) -- German climbing and hiking specialist
- [Intersport Scraper](https://apify.com/studio-amba/intersport-scraper) -- Europe's largest sports retail chain
- [Action Scraper](https://apify.com/studio-amba/action-scraper) -- Pan-European discount retailer
- [Kruidvat Scraper](https://apify.com/studio-amba/kruidvat-scraper) -- Belgian drugstore and beauty
- [ICI PARIS XL Scraper](https://apify.com/studio-amba/iciparisxl-scraper) -- Belgian beauty and perfume
- [Rituals Scraper](https://apify.com/studio-amba/rituals-scraper) -- Premium cosmetics and home fragrance
- [Mytheresa Scraper](https://apify.com/studio-amba/mytheresa-scraper) -- Luxury designer fashion

### Your feedback

Issues, feature requests, or questions? Reach out on the Apify Store actor page. We actively maintain this scraper and respond to all feedback.

# Actor input Schema

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

Search for products by keyword (e.g., 'jacket', 'sailing pants', 'ski gear').

## `categoryUrl` (type: `string`):

A Helly Hansen category page URL to scrape. Example: https://www.hellyhansen.com/en\_gb/men/jackets-and-coats. Leave empty to use search query instead.

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

Maximum number of products to return.

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

Proxy settings for avoiding rate limits.

## Actor input object example

```json
{
  "searchQuery": "jacket",
  "maxResults": 100
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQuery": "jacket"
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/hellyhansen-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "searchQuery": "jacket" }

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/hellyhansen-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 '{
  "searchQuery": "jacket"
}' |
apify call studio-amba/hellyhansen-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Helly Hansen Scraper — Outdoor & Sailing Apparel Prices",
        "description": "Scrape outdoor and sailing apparel from HellyHansen.com. Get product details, pricing, sizes, and technical specs from their Magento-based store.",
        "version": "0.1",
        "x-build-id": "qQ0ABtQFN95rrM9TS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~hellyhansen-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-hellyhansen-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/studio-amba~hellyhansen-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-hellyhansen-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/studio-amba~hellyhansen-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-hellyhansen-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",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by keyword (e.g., 'jacket', 'sailing pants', 'ski gear')."
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "A Helly Hansen category page URL to scrape. Example: https://www.hellyhansen.com/en_gb/men/jackets-and-coats. Leave empty to use search query instead."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for avoiding rate limits."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
