# Zara Scraper (`scraptivo/zara-scraper`) Actor

Collect Zara product catalogs from category pages and search, with optional size, composition, and description details. Enter a storefront, search terms, or category URLs and export prices, colors, sizes, and availability.

- **URL**: https://apify.com/scraptivo/zara-scraper.md
- **Developed by:** [Scraptivo](https://apify.com/scraptivo) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 product scrapeds

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Zara Scraper** collects Zara product catalogs from category pages and search results and turns them into structured data for price tracking, merchandising feeds, and competitive research. Provide a storefront, search terms, or category URLs, run the Actor, and export product names, prices, currency, colours, sizes, and availability to JSON, CSV, Excel, or your preferred integration. Use it to monitor prices, build assortment feeds, and schedule recurring collection across markets. Products are billed at $1.50 per 1,000, with optional size and composition details at the same rate.

### What can you automate with Zara Scraper?

- **Build category and search catalogs** — collect products from Zara category URLs, search terms, or both in one run.
- **Apply site filters** — narrow by colour, size, and price range, and sort by price or newness.
- **Track prices and availability** — capture product name, price, currency, colour variants, and stock status.
- **Enrich with product details** — add descriptions, composition, gallery images, and per-size SKU availability.
- **Cover multiple markets** — set the storefront for search and use country/language paths in URLs.
- **Automate exports** — deliver JSON, CSV, or Excel to a pipeline through the Apify API or webhooks.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| Retail and merchandising teams | Keep PIM or marketplace listings aligned with Zara's live catalog |
| Price-monitoring teams | Schedule runs on key categories and track changes over time |
| Competitive analysts | Compare assortment and pricing across categories or search terms |
| Market researchers | Run Germany, US, UK, and other storefronts in local currency |
| Automation builders | Trigger runs from the API, tasks, or webhooks when new data is needed |

### What data can you collect from Zara?

| Data group | Example fields | How it helps |
|---|---|---|
| Product identity | `name`, `productId`, `reference`, `displayReference`, `url` | Stable keys for deduplication and ERP feeds |
| Pricing and stock | `price`, `currency`, `availability` | Price tracking in the market currency |
| Visuals and variants | `imageUrl`, `images`, `color`, `colors`, `details` | Colourway and size-level analysis |
| Catalog context | `section`, `family`, `subfamily`, `categoryId` | Department and product grouping |
| Source tracking | `sourceQuery`, `sourceUrl` | Which search term or URL produced the row |

Detail fields such as description, composition, colours, and sizes are returned when `includeProductDetails` is enabled and the page provides them.

### How to use Zara Scraper

1. Open the Actor on Apify.
2. Add start URLs and/or search queries — at least one source is required.
3. Set the storefront, optional filters, and a `maxItems` limit.
4. Enable product details only if you need sizes and composition.
5. Run the Actor, then export results to JSON, CSV, Excel, or the API.

```json
{
  "startUrls": [{ "url": "https://www.zara.com/de/en/man-jeans-l659.html?v1=2432131" }],
  "searchQueries": ["shorts"],
  "storefront": "de/en",
  "filters": { "color": ["Black"], "priceMin": 20, "priceMax": 80 },
  "sort": "price-asc",
  "includeProductDetails": true,
  "maxItems": 50,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Example workflow

#### Keep a merchandising feed aligned with a Zara category

1. Run the Actor on a fixed category URL each day.
2. Enable `includeProductDetails` to capture sizes and composition.
3. Keep rows that changed price or stock in your downstream step.
4. Deduplicate on `productId`, then sync the result to a PIM or marketplace feed.

### Automate and integrate your results

- **Schedule** runs daily or weekly from the Apify Schedules tab, or create one schedule per high-value search term or category.
- **Webhooks** can trigger Slack, Zapier, or your warehouse when a run succeeds.
- **Connect** results to Google Sheets, Make, Zapier, a CRM, or cloud storage.
- **Deduplicate** downstream using the stable `productId` or `url`; use `maxItems` to cap cost during testing.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---|---:|---|---|
| `startUrls` | array | No\* | — | Zara category or product URLs |
| `searchQueries` | array | No\* | — | Search terms (use the `storefront` value) |
| `storefront` | string | No | `de/en` | Market for search, e.g. `us/en`, `uk/en` |
| `section` | string | No | — | Search section (`ALL`, `MAN`, `WOMAN`, `KID`, `HOME`) |
| `filters` | object | No | — | `color`, `size`, `priceMin`, `priceMax`, plus Zara filter keys |
| `sort` | string | No | — | `default`, `price-asc`, `price-desc`, or `novelty` |
| `includeProductDetails` | boolean | No | `false` | Whether to fetch description, composition, colours, and sizes |
| `detailConcurrency` | integer | No | — | Parallel detail requests when details are on |
| `maxItems` | integer | No | `20` | Maximum products to collect |
| `proxyConfiguration` | object | No | — | Proxy settings; residential is recommended |

\*Provide at least one of `startUrls` or `searchQueries`.

### Output example

```json
{
  "name": "ZW PREMIUM - Wide leg jeans",
  "productId": "2432131",
  "price": 49.95,
  "currency": "EUR",
  "availability": "In stock",
  "url": "https://www.zara.com/de/en/zw-premium-wide-leg-jeans-p2432131.html",
  "imageUrl": "https://static.zara.net/photos/.../jeans.jpg",
  "colors": [{ "name": "Black", "hex": "#000000" }],
  "section": "MAN",
  "sourceQuery": "shorts"
}
```

### How much does it cost to scrape Zara?

Zara Scraper uses pay-per-event pricing. You are billed per result you receive.

- **`product`** — $1.50 per 1,000 product rows saved to the dataset.
- **`product-details`** — $1.50 per 1,000 rows that include a `details` object when product details are enabled.

Listing-only runs charge only `product`. Detail runs charge `product` plus `product-details` for rows that include details. Apify subscription-plan discounts apply automatically. A small one-time `apify-actor-start` event ($0.00005) is also billed per run.

### Reliability and responsible use

- A residential proxy is recommended and enabled by default.
- Detail fields are conditional; some pages may not return descriptions, composition, or sizes.
- Currency follows the Zara storefront, for example EUR on `de/en` and USD on `us/en`.
- Collection is intended for public product data within your lawful-use scope; you remain responsible for complying with the site's terms.

### Frequently asked questions

#### Can I collect sizes and composition?

Yes. Enable `includeProductDetails` to add description, composition, all colourways, and per-size SKU availability. Enriched rows are billed under a separate `product-details` event.

#### Which currency appears in the output?

Currency comes from the Zara store: category and product URLs use the country/language in the path, while `searchQueries` use the `storefront` field. Switch to `us/en` or `uk/en` for USD or GBP.

#### Can I use category URLs and search together?

Yes. `startUrls` are processed first, then `searchQueries`; `maxItems` applies to the combined total.

#### What counts as one result?

Each product row written to the dataset counts as one `product` result. Rows with details also trigger `product-details`.

#### Why are some fields empty?

Detail fields depend on the page returning them. If a page omits a field, that field is left empty rather than invented.

#### How do I avoid duplicate records?

Re-runs can return the same product again. Deduplicate downstream on `productId` or `url`, and use `maxItems` to cap cost while testing.

### Related Scraptivo automations

- [Amazon Search Scraper](https://apify.com/scraptivo/amazon-scraper) — collect Amazon product and price data for competitor monitoring.
- [eBay Product Scraper](https://apify.com/scraptivo/ebay-scraper) — collect eBay listings, prices, and seller data.
- [Zalando Product Scraper](https://apify.com/scraptivo/zalando-scraper) — collect Zalando product listings and details.
- [Etsy Scraper](https://apify.com/scraptivo/etsy-scraper) — collect Etsy product listings and seller data.
- [IKEA Product Scraper](https://apify.com/scraptivo/ikea-scraper) — collect IKEA product listings and details.

### Support and custom workflows

Need a different field, source, or delivery workflow? Contact Scraptivo at scraptivo@gmail.com. Include the Actor name, a sample URL, required fields, and expected volume so we can assess the request.

# Actor input Schema

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

Zara category or product URLs, for example https://www.zara.com/de/en/man-jeans-l659.html?v1=2432131. The country and language in the path select the store and its currency.

## `searchQueries` (type: `array`):

Product search terms, for example shorts or linen shirt. Uses the Storefront field. You can combine these with start URLs.

## `storefront` (type: `string`):

Market for search queries, as country/language. For example de/en (Germany, English, EUR), us/en (United States, USD), or uk/en (United Kingdom, GBP). Category and product URLs use the market in the URL instead. Currency on each product comes from that store.

## `section` (type: `string`):

Department for search queries. Category URLs already belong to one department.

## `filters` (type: `object`):

Same filters as the Zara grid. colour and size match the on-site labels (for example Black or 36). priceMin and priceMax are in the store currency. Other on-site filter ids can be passed as extra keys, for example {"color": \["Black"], "size": \["36"], "priceMin": 20, "priceMax": 80}.

## `sort` (type: `string`):

Sort order. Featured keeps the site order. Price and New match the Zara sort control.

## `includeProductDetails` (type: `boolean`):

Fetch description, composition, colours, and sizes for each product. Charged as a product-details event in addition to the product event. Detail requests run in parallel, each with a new proxy.

## `detailConcurrency` (type: `integer`):

How many product detail requests to run at once when Include Product Details is enabled.

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

Maximum number of products to scrape. Use 0 for no limit.

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

Proxy settings. Residential proxies are recommended. When product details are enabled, each detail request uses a new proxy.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.zara.com/de/en/man-jeans-l659.html?v1=2432131"
    }
  ],
  "searchQueries": [
    "shorts"
  ],
  "storefront": "de/en",
  "section": "ALL",
  "filters": {},
  "sort": "default",
  "includeProductDetails": false,
  "detailConcurrency": 8,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset of Zara products

## `runStats` (type: `string`):

Product counts and timestamps for this run

# 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.zara.com/de/en/man-jeans-l659.html?v1=2432131"
        }
    ],
    "searchQueries": [
        "shorts"
    ],
    "storefront": "de/en",
    "filters": {},
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraptivo/zara-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.zara.com/de/en/man-jeans-l659.html?v1=2432131" }],
    "searchQueries": ["shorts"],
    "storefront": "de/en",
    "filters": {},
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scraptivo/zara-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.zara.com/de/en/man-jeans-l659.html?v1=2432131"
    }
  ],
  "searchQueries": [
    "shorts"
  ],
  "storefront": "de/en",
  "filters": {},
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraptivo/zara-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraptivo/zara-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/EqS5YdNb9JRV8iVN6/builds/mXfm113y1XMyrquqM/openapi.json