# Thirty Two Products Scraper (`parseforge/thirtytwo-products-scraper`) Actor

Scrapes product details from ThirtyTwo.com collection pages. Returns each product variant as a flat row with title, price, size, color, and image URLs.

- **URL**: https://apify.com/parseforge/thirtytwo-products-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.47 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Thirty Two Products Scraper

**Scrape snowboard boots, bindings, and outerwear from ThirtyTwo.com, including prices, sizes, and images.** Pull every product from any collection page or the full catalog in one run. Export to CSV, JSON, Excel, or XML.

Thirty Two's product catalog is spread across multiple collection pages, making manual tracking slow and error-prone. This Actor reads the public product listings directly, so you get a complete dataset without writing a single line of code. It handles pagination and extracts every variant, image, and price in a consistent flat schema.

| Who uses it | What they scrape Thirty Two for |
|---|---|
| E-commerce managers | Monitor Thirty Two's pricing and assortment to adjust their own snowboard gear listings. |
| Market analysts | Track seasonal product launches and color trends across the Thirty Two catalog. |
| Affiliate marketers | Build a live product feed of Thirty Two gear with current prices and availability. |
| Dropshippers | Sync Thirty Two's product images, titles, and variant data into their store backend. |

### What it does

This Actor collects product details from Thirty Two collection or product pages and returns each product variant as a flat row with its title, price, sizes, colors, and image URLs.

- 👢 **Full catalog or targeted scrape:** feed it the main collection URL or specific category pages like boots, bindings, or outerwear.
- 📏 **Variant-level detail:** each row captures a specific size and color combination with its own price and availability.
- 🖼️ **Image extraction:** collects all product and variant images in high resolution for your own listings or analysis.
- ⚙️ **Flexible volume control:** set a max items limit to run a quick preview or a deep full-catalog extraction.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Thirty Two data

**📊 Monitor competitor pricing.**

An e-commerce manager scrapes the Thirty Two boots collection weekly to track price changes and sale events, then adjusts their own store's pricing strategy.

**📸 Build a product feed for a snowboard gear blog.**

An affiliate marketer scrapes the full catalog monthly to populate a searchable product database with current images, prices, and direct links.

**📦 Sync inventory for a dropshipping store.**

A dropshipper scrapes specific outerwear categories daily to update their store's product listings with the latest available sizes and colors.

**🔍 Analyze seasonal product trends.**

A market analyst scrapes the entire Thirty Two catalog at the start of each season to catalog new colorways, technologies, and product line expansions.

### Why choose this scraper

| | What you get |
|---|---|
| **Consistent flat schema** | Every product variant is a single row, ready for spreadsheets or databases. |
| **No code required** | enter a URL and a limit; the Actor handles pagination and extraction. |
| **Current pricing data** | Scrapes the live site so you always get the latest prices and sales. |
| **Variant-level granularity** | Captures every size and color option as its own record with specific details. |

### How it compares

No other Store actor targets Thirty Two the same way, so the honest comparison is with the alternatives teams actually weigh.

| | Thirty Two Products Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When Thirty Two changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor from any Thirty Two collection or product URL, and set a max items limit to control the size of your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "startUrls": [
 {
 "url": "https://www.thirtytwo.com/collections/all"
 }
 ],
 "maxItems": 10
}
```

A larger pull:

```json
{
 "startUrls": [
 {
 "url": "https://www.thirtytwo.com/collections/all"
 }
 ],
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.02262 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $2.26 |
| 1,000 results | $22.62 |
| 10,000 results | $226.20 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Thirty Two Products Scraper](https://apify.com/parseforge/thirtytwo-products-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Thirty Two through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/thirtytwo-products-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that the Start URL points to a valid Thirty Two collection or product page. If the page loads products dynamically, try running the Actor with a slightly longer timeout or ensure the URL is correct.

**The scraper is only returning 10 items.**

Free accounts are limited to a 10-item preview. Upgrade to a paid Apify plan and increase the Max Items setting to scrape more products.

**Some product images are missing in the output.**

Images are loaded from the page as they appear. If a product has many variants, ensure the page had time to render all images. A rerun usually resolves intermittent missing assets.

**The run is taking a long time.**

Scraping the full catalog with many variants can take time. Reduce the Max Items limit for a faster preview, or let the run complete for a full dataset.

### FAQ

| Question | Answer |
|---|---|
| Can I scrape only a specific category like boots? | Yes. Paste the URL of any collection page, such as the boots or bindings category, into the Start URLs field and the Actor will scrape only those products. |
| Does this Actor extract product images? | Yes. It collects the main product image and all variant-specific images in high resolution, returning the direct URLs in the dataset. |
| How are product variants like size and color handled? | Each unique combination of size and color is returned as its own row, with the specific price, availability, and image for that variant. |
| What format is the data exported in? | You can export your results in JSON, CSV, Excel, or XML directly from the Apify dataset tab. |
| Is there a limit to how many products I can scrape? | Free accounts are limited to a 10-item preview. Paid accounts can scrape up to 1,000,000 items per run by adjusting the Max Items setting. |
| Does this Actor handle pagination automatically? | Yes. It follows all 'next page' links on collection pages until it reaches your max items limit or the end of the catalog. |
| Can I scrape multiple collection pages in one run? | Yes. Add multiple URLs to the Start URLs array and the Actor will process them sequentially, combining all results into one dataset. |
| Do I need an API key or login for Thirty Two? | No. This Actor scrapes the publicly accessible product pages, so no login, API key, or account is required. |
| How often can I run this scraper? | You can schedule runs as frequently as you need. For regular monitoring, set up an Apify schedule to run daily or weekly. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Thirty Two, Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

URLs of Thirty Two collection or product pages to scrape. Defaults to the full catalog.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.thirtytwo.com/collections/all"
    }
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

Complete dataset of all scraped records.

# 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://www.thirtytwo.com/collections/all"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/thirtytwo-products-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://www.thirtytwo.com/collections/all" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/thirtytwo-products-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 '{
  "startUrls": [
    {
      "url": "https://www.thirtytwo.com/collections/all"
    }
  ],
  "maxItems": 10
}' |
apify call parseforge/thirtytwo-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/thirtytwo-products-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/kz3VmshA3c5kUfRvY/builds/UDvxBgXed07Fym2Ts/openapi.json