# Arc'teryx Product Scraper (`solidcode/arcteryx-scraper`) Actor

\[💰 $7 / 1K] Extract Arc'teryx products — names, prices, colors, sizes, SKUs, stock status, materials, images, and ratings. Scrape by product URL, category, or keyword across US, Canada, UK, and EU stores with local currency and language.

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

## Pricing

from $7.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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.

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

## Arc'teryx Product Scraper

Pull the full Arc'teryx catalog — prices, colorways, per-SKU variants, sizes, materials, ratings, and stock — from any of nine regional storefronts in local currency. Point it at a category page, an on-site keyword search, or a single product link and get one clean, structured row per product. Built for resale sellers, competitive price-monitoring teams, and outdoor-retail analysts who need a dependable Arc'teryx product feed without tracking down every product URL by hand.

### Why This Scraper?

- **Per-SKU variant matrix on every product** — each colorway × size combination is its own row (SKU, color, size, price), up to 40+ variants on styles like the Squamish Hoody. Rebuild the exact size run a store carries, not just a headline price.
- **9 country storefronts in native currency** — read prices and availability straight from the US, Canada, UK, Germany, France, Austria, Switzerland, Spain, or Belgium store, returned in USD, CAD, GBP, CHF, or EUR exactly as a local shopper sees them.
- **4 content languages** — collect product names and descriptions in English, French, German, or Spanish, so your feed matches the market you sell into.
- **13 base-color filters and 8 sort orders** — narrow a category to Black, Blue, Grey, Multi, or any of 13 colors, then order by price, weight, newest, or top rated before you spend a single result.
- **Star rating and review count on every row** — the average rating (e.g. 4.55) and total review count come attached to the product record itself, with no extra lookup.
- **Honest sale pricing, no placeholder junk** — a discounted item returns its real sale price; a full-price item correctly returns `null`, so you never mistake a "999999" sentinel for a markdown.
- **Up to 8 product images plus material tags** — the full image gallery alongside GORE-TEX® and fabric callouts and a long material description for every style.
- **Men's, Women's, Unisex, and in-stock filtering** — restrict a run to one audience and, optionally, to only what's buyable online right now, across both categories and keyword searches.
- **Whole categories in one run** — paginate an entire subcategory (verified 96 products across multiple pages) with a maximum-products cap that overshoots to finish the current page but never trims your data mid-run.

### Use Cases

**Resale & Reselling**
- Price incoming inventory against current Arc'teryx retail in the exact market you sell in
- Track which colorways and sizes are still in stock before sourcing
- Spot markdowns the moment a style goes on sale
- Build size-run tables per style from the per-SKU variant matrix

**Competitive Price Monitoring**
- Compare the same style's price across the US, Canada, UK, and EU stores
- Detect sale events and discount depth by watching sale price vs. regular price
- Alert on new-arrival pricing by sorting a category by newest
- Benchmark your own outdoor-apparel pricing against a premium brand

**Market & Assortment Research**
- Map an entire category's assortment by gender, color, and price band
- Rank styles by star rating and review volume to find bestsellers
- Track how many colorways each style ships with over time
- Analyze material mixes (GORE-TEX®, down, fleece) across a collection

**Inventory & Availability Tracking**
- Flag sold-out and coming-soon products with the in-stock filter
- Monitor which sizes and colors disappear first on popular styles
- Keep a live catalog of what a regional store is currently selling

**Catalog & Content Enrichment**
- Populate a product database with names, descriptions, features, and images
- Localize an existing catalog into French, German, or Spanish
- Feed ratings and review counts into merchandising dashboards

### Getting Started

#### Scrape a Category

The simplest run — paste a subcategory page and collect every product in it:

```json
{
    "startUrls": [
        { "url": "https://arcteryx.com/us/en/c/mens/shell-jackets" }
    ],
    "maxItems": 50
}
````

#### Search by Keyword

No URL needed — search the on-site catalog directly:

```json
{
    "searchTerms": ["beta jacket", "rain shell"],
    "maxItems": 30
}
```

#### Advanced Multi-Filter

Narrow a women's category to blue, in-stock styles, newest first, priced in British pounds:

```json
{
    "startUrls": [
        { "url": "https://arcteryx.com/us/en/c/womens/shell-jackets" }
    ],
    "gender": "womens",
    "colors": ["blue", "black"],
    "inStockOnly": true,
    "sortBy": "newest",
    "country": "gb",
    "language": "en",
    "maxItems": 100
}
```

#### A Single Product

Paste one product link to get its full detail record:

```json
{
    "startUrls": [
        { "url": "https://arcteryx.com/us/en/shop/mens/beta-jacket" }
    ]
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | URL\[] | `[shell-jackets]` | Arc'teryx product, category (`/c/...`), or search URLs. The page type is detected automatically and every product found is collected. |
| `searchTerms` | string\[] | `[]` | Keywords such as "beta jacket". Each keyword runs its own on-site search; every matching product is collected. |

#### Filters

Filters apply to category and keyword collection. A single pasted product URL is always returned regardless of filters.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `gender` | select | `Any` | Keep only one audience: `Any`, `Men's`, `Women's`, or `Unisex`. |
| `colors` | multi-select | `[]` | Keep only products offered in these base colors: Black, Blue, Brown, Green, Grey, Multi, Natural, Orange, Pink, Purple, Red, White, Yellow. |
| `inStockOnly` | boolean | `false` | Collect only products currently available to buy online. Off includes sold-out and coming-soon items. |
| `sortBy` | select | `Recommended` | Order products are collected in: `Recommended`, `What's New`, `Top Rated`, `Price: Low to High`, `Price: High to Low`, `Name: A to Z`, `Name: Z to A`, `Weight: Low to High`. |

#### Localization

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `country` | select | `United States (USD)` | Regional store that sets currency and availability: United States (USD), Canada (CAD), United Kingdom (GBP), Germany (EUR), France (EUR), Austria (EUR), Switzerland (CHF), Spain (EUR), Belgium (EUR). |
| `language` | select | `English` | Language for product names and descriptions: `English`, `French`, `German`, `Spanish`. The nearest supported option is used when a language isn't offered in a store. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxItems` | integer | `100` | Stop after this many products in total across all URLs and keywords. Set to `0` to collect everything found. |

### Output

Each product becomes one dataset row. Here's a representative result:

```json
{
    "productId": "X000005111",
    "name": "Beta Jacket Men's",
    "brand": "Arc'teryx",
    "category": "Shell Jackets",
    "categoryPath": ["Jackets", "Shell Jackets"],
    "gender": "mens",
    "description": "An all-round GORE-TEX shell for everyday mountain use.",
    "features": ["GORE-TEX ePE membrane", "Helmet-compatible StormHood", "Pit zippers"],
    "materials": "GORE-TEX® (Waterproof), 40D nylon face fabric",
    "price": 500,
    "salePrice": null,
    "currency": "USD",
    "inStock": true,
    "rating": 4.55,
    "reviewCount": 112,
    "colorCount": 4,
    "colors": [
        { "name": "Black", "baseColor": "Black", "hex": "#1a1a1a", "swatchImage": "https://.../swatch.jpg", "image": "https://.../black.jpg" }
    ],
    "sizes": ["S", "M", "L", "XL"],
    "variants": [
        { "sku": "12345-BLACK-M", "color": "Black", "size": "M", "price": 500, "salePrice": null, "image": "https://.../black.jpg" }
    ],
    "images": ["https://.../beta-1.jpg", "https://.../beta-2.jpg"],
    "url": "https://arcteryx.com/us/en/shop/mens/beta-jacket-0511",
    "country": "us",
    "language": "en",
    "scrapedAt": "2026-07-17T14:30:00Z"
}
```

#### Core Product Fields

| Field | Type | Description |
|-------|------|-------------|
| `productId` | string | Arc'teryx model / style identifier |
| `name` | string | Product name in the selected language |
| `brand` | string | Always "Arc'teryx" |
| `category` | string | Primary category (e.g. "Shell Jackets") |
| `categoryPath` | string\[] | Full category breadcrumb path |
| `gender` | string | `mens`, `womens`, or `unisex` |
| `description` | string | Short product description |
| `features` | string\[] | Product feature highlights |
| `materials` | string | Material tags plus a long material description |
| `inStock` | boolean | Whether the product is currently buyable online |
| `url` | string | Canonical product URL for the selected store |
| `country` | string | Store country the row was collected from |
| `language` | string | Language the text was collected in |
| `scrapedAt` | string | ISO 8601 timestamp of extraction |

#### Pricing & Ratings

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Regular price in the store's local currency |
| `salePrice` | number | null | Sale price when discounted; `null` at full price |
| `currency` | string | ISO currency code (USD, CAD, GBP, EUR, CHF) |
| `rating` | number | null | Average star rating (e.g. 4.55) |
| `reviewCount` | integer | null | Number of customer reviews |

#### Colors, Sizes & Variants

| Field | Type | Description |
|-------|------|-------------|
| `colorCount` | integer | Number of available colorways |
| `colors` | object\[] | Each colorway: `name`, `baseColor`, `hex`, `swatchImage`, `image` |
| `sizes` | string\[] | Distinct available sizes |
| `variants` | object\[] | Per-SKU rows: `sku`, `color`, `size`, `price`, `salePrice`, `image` |

#### Media

| Field | Type | Description |
|-------|------|-------------|
| `images` | string\[] | Product image gallery URLs (up to 8 per product) |

### Tips for Best Results

- **Use a subcategory URL, not a hub page.** A top-level hub like `/c/mens/jackets` returns nothing — point at a leaf subcategory such as `/c/mens/shell-jackets` (or the bare `/c/mens` for the full men's range) to get products.
- **Store Country drives currency.** Set the country to price the whole catalog the way a local shopper sees it — the same style returns USD from the US store and GBP from the UK store.
- **Combine gender and colors to zero in fast.** Pairing `Women's` with one or two base colors trims a large category to exactly the styles you care about before any results are spent.
- **Pair sort with a small cap for freshness.** Sort by `What's New` (or `Top Rated`) with a modest `maxItems` to grab just the latest arrivals or the highest-rated styles first.
- **Search when you don't have URLs.** Keyword search returns complete product records, so "beta jacket" is often faster than hunting down category links.
- **Start small, then scale.** Run with `maxItems` at 20–50 to confirm the fields match your needs, then raise the cap for a full pull.
- **Language falls back gracefully.** Not every language is offered in every store; the closest supported option is used automatically, so a French request against a UK store still resolves.

### Pricing

**From $7.00 per 1,000 results** — richer output than the alternatives (per-SKU variants, ratings, localized pricing, and image galleries) at a lower headline rate. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.84 | $0.79 | $0.75 | $0.70 |
| 1,000 | $8.40 | $7.90 | $7.45 | $7.00 |
| 10,000 | $84.00 | $79.00 | $74.50 | $70.00 |
| 100,000 | $840.00 | $790.00 | $745.00 | $700.00 |

A "result" is any product row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate product research, price monitoring, and catalog analysis. You are responsible for complying with applicable laws and Arc'teryx's Terms of Service. Collect only publicly available product information, respect the website's usage policies, and do not use extracted data for any unlawful purpose.

# Actor input Schema

## `startUrls` (type: `array`):

Paste Arc'teryx page URLs — individual product pages (e.g. .../shop/mens/beta-jacket), a whole category (e.g. .../c/mens/shell-jackets), or a search results page. The scraper detects the page type automatically and collects every product it finds.

## `searchTerms` (type: `array`):

Search Arc'teryx by keyword, for example 'beta jacket' or 'rain shell'. Each keyword runs its own search and every matching product is collected. Leave empty if you only want to use URLs above.

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

Keep only products for this audience. Applies to category and keyword collection.

## `colors` (type: `array`):

Keep only products available in these base colors. Leave empty to include all colors.

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

Only collect products that are currently available to buy online. Turn off to include sold-out and coming-soon items.

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

Order in which products are collected from category pages and searches. Useful with a result limit — for example, sort by newest to grab the latest arrivals first.

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

Which Arc'teryx regional store to read prices and availability from. This sets the currency and stock shown for each product.

## `language` (type: `string`):

Language for product names and descriptions. Not every language is available in every store — the closest supported option is used automatically.

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

Stop after collecting this many products in total across all URLs and keywords. Set to 0 to collect everything found.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://arcteryx.com/us/en/c/mens/shell-jackets"
    }
  ],
  "searchTerms": [],
  "gender": "any",
  "colors": [],
  "sortBy": "relevance",
  "country": "us",
  "language": "en",
  "maxItems": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped products with key fields.

# 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 = {
    "startUrls": [
        {
            "url": "https://arcteryx.com/us/en/c/mens/shell-jackets"
        }
    ],
    "searchTerms": [],
    "gender": "any",
    "colors": [],
    "inStockOnly": false,
    "sortBy": "relevance",
    "country": "us",
    "language": "en",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/arcteryx-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 = {
    "startUrls": [{ "url": "https://arcteryx.com/us/en/c/mens/shell-jackets" }],
    "searchTerms": [],
    "gender": "any",
    "colors": [],
    "inStockOnly": False,
    "sortBy": "relevance",
    "country": "us",
    "language": "en",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/arcteryx-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 '{
  "startUrls": [
    {
      "url": "https://arcteryx.com/us/en/c/mens/shell-jackets"
    }
  ],
  "searchTerms": [],
  "gender": "any",
  "colors": [],
  "inStockOnly": false,
  "sortBy": "relevance",
  "country": "us",
  "language": "en",
  "maxItems": 100
}' |
apify call solidcode/arcteryx-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Arc'teryx Product Scraper",
        "description": "[💰 $7 / 1K] Extract Arc'teryx products — names, prices, colors, sizes, SKUs, stock status, materials, images, and ratings. Scrape by product URL, category, or keyword across US, Canada, UK, and EU stores with local currency and language.",
        "version": "1.0",
        "x-build-id": "aAOE3B3x6jhTneCy3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~arcteryx-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-arcteryx-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/solidcode~arcteryx-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-arcteryx-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/solidcode~arcteryx-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-arcteryx-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": {
                    "startUrls": {
                        "title": "Product, Category or Search URLs",
                        "type": "array",
                        "description": "Paste Arc'teryx page URLs — individual product pages (e.g. .../shop/mens/beta-jacket), a whole category (e.g. .../c/mens/shell-jackets), or a search results page. The scraper detects the page type automatically and collects every product it finds.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchTerms": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Search Arc'teryx by keyword, for example 'beta jacket' or 'rain shell'. Each keyword runs its own search and every matching product is collected. Leave empty if you only want to use URLs above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "gender": {
                        "title": "Gender",
                        "enum": [
                            "any",
                            "mens",
                            "womens",
                            "unisex"
                        ],
                        "type": "string",
                        "description": "Keep only products for this audience. Applies to category and keyword collection."
                    },
                    "colors": {
                        "title": "Colors",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Keep only products available in these base colors. Leave empty to include all colors.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "black",
                                "blue",
                                "brown",
                                "green",
                                "grey",
                                "multi",
                                "natural",
                                "orange",
                                "pink",
                                "purple",
                                "red",
                                "white",
                                "yellow"
                            ],
                            "enumTitles": [
                                "Black",
                                "Blue",
                                "Brown",
                                "Green",
                                "Grey",
                                "Multi",
                                "Natural",
                                "Orange",
                                "Pink",
                                "Purple",
                                "Red",
                                "White",
                                "Yellow"
                            ]
                        }
                    },
                    "inStockOnly": {
                        "title": "In Stock Only",
                        "type": "boolean",
                        "description": "Only collect products that are currently available to buy online. Turn off to include sold-out and coming-soon items."
                    },
                    "sortBy": {
                        "title": "Sort Order",
                        "enum": [
                            "relevance",
                            "newest",
                            "top_rated",
                            "price_asc",
                            "price_desc",
                            "name_asc",
                            "name_desc",
                            "weight_asc"
                        ],
                        "type": "string",
                        "description": "Order in which products are collected from category pages and searches. Useful with a result limit — for example, sort by newest to grab the latest arrivals first."
                    },
                    "country": {
                        "title": "Store Country",
                        "enum": [
                            "us",
                            "ca",
                            "gb",
                            "de",
                            "fr",
                            "at",
                            "ch",
                            "es",
                            "be"
                        ],
                        "type": "string",
                        "description": "Which Arc'teryx regional store to read prices and availability from. This sets the currency and stock shown for each product."
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "fr",
                            "de",
                            "es"
                        ],
                        "type": "string",
                        "description": "Language for product names and descriptions. Not every language is available in every store — the closest supported option is used automatically."
                    },
                    "maxItems": {
                        "title": "Maximum Products",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after collecting this many products in total across all URLs and keywords. Set to 0 to collect everything found."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
