# Zara Scraper - Prices, Rebajas, Variants & Composition (`abotapi/zara-com-scraper`) Actor

Scrape Zara (zara.com) products: current price plus strike-through Rebajas (sale) discount, full colour variant matrix with per-colour availability, and (with full detail) fabric composition and a per-size availability/price matrix. Browse by category or Rebajas, or paste links.

- **URL**: https://apify.com/abotapi/zara-com-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 10 total users, 2 monthly users, 93.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 product 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?

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: Prices, Rebajas, Variants & Composition

Zara Scraper turns Zara (zara.com) into a clean product data API. Browse any category or Zara's own Rebajas (sale) catalog for a section, or paste product and category/listing links directly. Every record carries the current price, the strike-through original price and discount percentage when a product is genuinely on Rebajas, and the full colour variant matrix with per-colour availability, plus fabric composition and a real per-size availability/price matrix when you switch on full detail. Export to JSON, CSV or Excel, or pull results straight into your app through the API.

### Why This Scraper?

- **Was-price and discount, straight from Zara's own pricing data.** When a product is genuinely on Rebajas, the record carries the current price, the strike-through original price and the discount percentage, gated on the site's own price delta rather than guessed. Full-price products return these fields as null.
- **Rebajas, first class.** A `specialsOnly` toggle browses the chosen section's real, currently running Rebajas (sale) catalog instead of a specific category, typically thousands of genuinely marked-down items.
- **Full colour variant matrix.** Every colourway Zara sells for a product, each with its own price, availability and image gallery.
- **Real per-size detail on demand.** Switch on full detail to add fabric composition (a material breakdown by percentage, per garment part) and a real per-size matrix (in stock / out of stock, and each size's own price) for every colour.
- **Two ways in.** Browse a category or Rebajas feed, or paste any product or category link; the same keyword, colour, size and price filters apply to both.
- **Deduplicated by design.** A product reached twice, whether through overlapping category pages or a pasted link pasted more than once, is emitted, and billed, exactly once per run.
- **Optional export to your apps.** Send results into Notion, Linear, Airtable or any Apify MCP connector alongside the dataset.

### Use Cases

- **Price and discount tracking:** monitor Rebajas markdowns across a section or category over time to spot the biggest drops first.
- **Fashion market research:** pull structured price, variant and composition data across categories for competitor or trend analysis.
- **Catalog and marketplace building:** paste category links to build a product feed with full colour and size availability.
- **Stock and size alerts:** check a specific product URL to see which sizes are currently in stock before a colourway sells out.
- **AI agents and chat commerce:** feed clean structured product data into an agent or app, optionally piping a summary straight into Notion, Linear or Airtable.

### Data You Get

| Field | Example |
| --- | --- |
| `productId` | `"07521308"` |
| `name` | `"Sample Ribbed Knit Dress"` |
| `brand` | `"Zara"` (Zara sells only its own brand, so this is constant) |
| `reference` | `"1234/567/800"` |
| `section` | `"WOMAN"` |
| `family` | `"Dresses"` |
| `subfamily` | `"Midi"` |
| `kind` | `"Clothing"` |
| `description` | `"Midi dress with a round neckline and long sleeves."` |
| `url` | `"https://www.zara.com/es/es/sample-ribbed-knit-dress-p07521308.html?v1=545409966"` |
| `currency` | `"EUR"` |
| `price` | `15.99` |
| `oldPrice` / `originalPrice` / `discountPercent` / `isOnSale` | `25.99` / `25.99` / `38` / `true` (only when genuinely on Rebajas; otherwise all null and `isOnSale: false`) |
| `availability` | `"in_stock"` |
| `image` | `"https://static.zara.net/photos/sample/image1.jpg"` (the default colour's first photo) |
| `defaultColorId` | `"800"` |
| `colors[]` | one entry per colourway: `id`, `name`, `hexColor`, `discernProductId`, `availability`, `images[]`, `currency`, and that colour's own price/was-price fields |
| `colors[].sizes[]` | `id`, `name`, `availability`, `sku`, price/was-price per size (only populated when full detail is on) |
| `compositions` | `[{"part": "Outer shell", "materials": [{"material": "Cotton", "percentage": "95%"}, {"material": "Elastane", "percentage": "5%"}]}]` (only populated when full detail is on) |
| `reviews` | `[]` |
| `id`, `type`, `sectionName`, `familyName`, `subfamilyName`, `keyword`, `displayReference` | Zara's tile id, record type, section / family / subfamily names, URL slug and printed reference |
| `images[]`, `pricing` | the default colour's gallery and a price object (`price`, `oldPrice`, `originalPrice`, `discountPercent`, `isOnSale`, `currency`) |
| `extraInfo` | Zara's own brand / flag object for the tile |
| `description`, `detailedComposition`, `relatedProducts`, `firstVisibleDate`, `state`, `familyId`, `subfamilyId` | read from the product's own page data when full detail is on; `description` is the plain-text product description, `relatedProducts` lists the related-look product ids Zara links to (`id` and `type`). A value Zara does not send stays `null` / `[]` (never invented) |

> Sample shape: values above are illustrative placeholders, not from a live product.

Zara does not surface customer reviews on its product pages, so `reviews` is always returned as an empty list rather than omitted or guessed. Each entry in `colors[]` carries its own `discernProductId` (the numeric id Zara uses internally for that colourway) and up to 8 gallery images; `colors[].sizes[]` stays an empty list until full detail is switched on, since per-size availability is a separate fetch. Zara is a single-brand shop, so every record's `brand` is `"Zara"`.

### How to Use

1. Pick a **mode**: `search` (browse a category or Rebajas) or `url` (paste product or category links).
2. For search mode, choose a **section** and either a **Category id** or **Rebajas only**; for URL mode, paste one or more links.
3. Narrow with the keyword, colour, size, price and sort filters, which apply in both modes, and switch on **Fetch full product detail** if you need composition and per-size availability.
4. Set **Max products total** to control run size and cost, then click **Start**. Download the dataset as JSON, CSV or Excel, or read it through the API.

**Browse the women's Rebajas (sale) catalog, biggest discount first:**

```json
{
  "mode": "search",
  "section": "WOMAN",
  "specialsOnly": true,
  "sortBy": "discountDesc",
  "maxItems": 50
}
```

**Browse a specific category id in the UK market, within a price band:**

```json
{
  "mode": "search",
  "market": "gb/en",
  "categoryId": "2420896",
  "minPrice": 20,
  "maxPrice": 80,
  "maxItems": 40
}
```

**Paste a category/listing link, full detail on, only sizes with an M in stock:**

```json
{
  "mode": "url",
  "urls": ["https://www.zara.com/es/es/mujer-vestidos-l1066.html"],
  "fetchDetails": true,
  "sizes": ["M"],
  "maxItems": 30
}
```

**Paste a single product link and pipe it into Notion:**

```json
{
  "mode": "url",
  "urls": ["https://www.zara.com/es/es/sample-ribbed-knit-dress-p07521308.html?v1=545409966"],
  "mcpConnectors": ["YOUR_CONNECTOR_ID"],
  "notionParentPageUrl": "https://www.notion.so/my-workspace/Zara-Finds-abc123"
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/zara-com-scraper").call(run_input={"mode": "search", "section": "WOMAN", "specialsOnly": True})
for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(product["name"], product["price"], product["discountPercent"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/zara-com-scraper').call({ mode: 'search', section: 'WOMAN', specialsOnly: true });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### Full detail, sizes, and the cap

**Fetch full product detail** adds the product description, fabric composition, family and state, first-visible date, related looks and a real per-size matrix for every colour; the current price, was-price/discount and colour-level availability are already included without it. A pasted single product URL always fetches full detail, regardless of this toggle. Because the per-size matrix only exists once full detail runs, the **Sizes** filter is applied after **Max products total** has already capped the result set, not before, so it narrows the capped page rather than the whole catalogue. Raise **Max products total**, or set it to `0`, if a size filter is returning fewer products than you expect.

#### Rebajas vs a specific category

**Rebajas (sale) only** takes priority over **Category id** when both are set: turn it off to browse a specific category instead. Search mode needs at least one of the two; leaving both empty returns no products.

#### URL shapes (URL mode)

**Behaviour change:** URL mode with the `urls` field left untouched now scrapes one example of each shape below (still limited by Max products total); previously it scraped one category link. An explicitly empty list now fails the run instead of finishing with zero rows.

| Link shape | Example | What you get |
| --- | --- | --- |
| Category page (`-l<id>.html`) | `https://www.zara.com/es/es/mujer-vestidos-l1066.html` | The category's products |
| Category products JSON (numeric id) | `https://www.zara.com/es/es/category/2420896/products?ajax=true` | The category's products, id read directly |
| Category tree JSON | `https://www.zara.com/es/es/categories?ajax=true` | A market-wide browse: the first categories of the chosen **section** in that link's market |
| Keyword search page | `https://www.zara.com/es/es/search?searchTerm=vestido` | Products of the Zara categories whose name matches the keyword (Zara's own search page ships no products server-side) |
| Keyword search JSON | `https://www.zara.com/es/es/search?searchTerm=vestido&ajax=true` | Same as the keyword search page |
| Product page (`-p<id>.html?v1=<id>`) | `https://www.zara.com/es/es/vestido-tirantes-abalorios-flecos-zw-collection-limited-edition-p06895279.html?v1=558218255` | One product with full detail, all of its colours (not in the default list, because a pasted product always fetches full detail, an optional billed event) |
| Product details JSON | `https://www.zara.com/es/es/products-details?productIds=558218255&ajax=true` | The product behind each listed colour id, with full detail and all of its colours (not in the default list, same reason) |

#### Scheduled runs: incremental mode and resume

Turn on `incrementalMode` for daily or weekly monitoring of the same search. The first run returns every matching product as `NEW`; later runs return only `NEW`, `UPDATED` and `REAPPEARED` products, each with `changeType`, `changedFields`, `firstSeenAt` and `lastSeenAt`. Products that did not change are not returned and are not billed. Turn on `emitUnchanged` or `emitExpired` only if you also want those rows: they are dataset rows like any other and are billed as product results. `EXPIRED` rows are only produced after a run that scanned the whole search (never when `maxItems` capped it, when Resume was used, or when a page failed to load). State is kept per search, filter and detail setup; set `stateKey` to name a campaign yourself, and `ignoreFieldsForChanges` to leave noisy fields out of change detection (they are still returned). `resumeFromRunId` continues one interrupted run without returning or billing products it already collected. With incremental mode off the output is exactly as before.

#### Output views

The dataset has five views (the fifth, **Changes**, is for incremental mode): **Products** (overview: id, name, prices, sale state), **Colour/size variants** (nested colours and sizes), **Composition** (detail fields, filled when full detail ran) and **Taxonomy & reference** (section, family, subfamily, keyword, reference).

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each product, not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` (browse a category or Rebajas) or `url` (paste links). |
| `market` | string | `es/es` | Zara's own market path prefix, e.g. `gb/en`. Search mode only; a pasted URL carries its own market. |
| `section` | string | `WOMAN` | `WOMAN`, `MAN`, `KID`, or `BEAUTY`. Drives the Rebajas catalog and labels results. |
| `categoryId` | string | no default (prefill: `2420896`) | A specific Zara category id to browse. Ignored when Rebajas only is on. Search mode only. |
| `specialsOnly` | boolean | `false` | Browse the chosen section's real, currently running Rebajas (sale) catalog instead of a specific category id. Search mode only. |
| `urls` | array | one example of each supported link shape (see URL shapes below) | Links to scrape, any market. URL mode only; search-mode fields are ignored here. An explicitly empty list fails the run. |
| `searchTerm` | string | no default (empty) | Keep only products whose name or description contains this text. Applies in both search and URL mode. In search mode with no Category id and no Rebajas only, a plain word (for example `vestido`, `camiseta`) is matched against Zara category names (up to 3 categories) and those are browsed. |
| `colors` | array | no default (empty) | Keep only products with a colourway matching one of these names, case-insensitive and partial. Applies in both modes. |
| `productUrls` | array | none | Alias of `urls` (strings or `{"url": ...}` objects); `urls` wins if both are set. |
| `sizes` | array | no default (empty) | Keep only products with one of these sizes in stock. In search mode and pasted category links, size data only exists when **Fetch full product detail** is on, so setting Sizes without it returns zero products (the run logs a warning); a pasted product URL always has size data. |
| `minPrice` | number | no default (empty) | Only return products priced at or above this amount, in the market's currency. Applies in both modes. |
| `maxPrice` | number | no default (empty) | Only return products priced at or below this amount, in the market's currency. Applies in both modes. |
| `sortBy` | string | `relevance` | Order results after filtering: relevance (catalog order), price low to high, price high to low, or biggest discount first. |
| `fetchDetails` | boolean | `false` | Add the product description, fabric composition, family/state/first-visible date, related looks and a real per-size availability/price matrix. A pasted product URL always fetches full detail regardless of this toggle. |
| `maxItems` | integer | `20` | Hard cap on total products returned across every search/URL entry. `0` = unlimited. |
| `proxy` | object | Apify Proxy | Connection settings for reaching zara.com. Starts on the selected connection and escalates to residential (paid plan) or a backup connection when a route is refused; choose residential or your own proxy URLs to start there. Free plans have no Apify proxy (see Plan Requirement). |
| `resumeFromRunId` | string | no default (empty) | Run ID or dataset ID of an earlier run to continue without returning or billing products it already collected. |
| `incrementalMode` | boolean | `false` | Return only products that are new or changed since the last run of the same search. |
| `stateKey` | string | no default (empty) | Name a monitoring campaign, or deliberately share state across runs. Empty = derived from the search. |
| `emitUnchanged` | boolean | `false` | Also return unchanged products (billed as product results). Incremental mode only. |
| `emitExpired` | boolean | `false` | Also return products that disappeared after a complete scan (billed as product results). Incremental mode only. |
| `ignoreFieldsForChanges` | array | no default (empty) | Field names (dotted paths allowed) that should not make a product count as UPDATED. Incremental mode only. |
| `mcpConnectors` | array | no default (empty) | Optional: send a summary of each product to apps you authorized under Integrations. |
| `notionParentPageUrl` | string | no default (empty) | Notion connector only: page under which item pages are created. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run. Does not affect the dataset. |

### Output Example

> Sample shape: values below are illustrative placeholders, not from a live product.

```json
{
  "productId": "07521308",
  "name": "Sample Ribbed Knit Dress",
  "brand": "Zara",
  "reference": "1234/567/800",
  "section": "WOMAN",
  "family": "Dresses",
  "subfamily": "Midi",
  "kind": "Clothing",
  "description": "Midi dress with a round neckline and long sleeves.",
  "url": "https://www.zara.com/es/es/sample-ribbed-knit-dress-p07521308.html?v1=545409966",
  "currency": "EUR",
  "defaultColorId": "800",
  "price": 15.99,
  "oldPrice": 25.99,
  "originalPrice": 25.99,
  "discountPercent": 38,
  "isOnSale": true,
  "availability": "in_stock",
  "image": "https://static.zara.net/photos/sample/image1.jpg",
  "colors": [
    {
      "id": "800",
      "name": "Black",
      "hexColor": "#000000",
      "discernProductId": "545409966",
      "availability": "in_stock",
      "images": [
        { "url": "https://static.zara.net/photos/sample/image1.jpg", "width": 1500, "height": 2250, "kind": "GENERAL" }
      ],
      "sizes": [
        { "id": "S", "name": "S", "availability": "out_of_stock", "sku": 12345678, "price": 15.99, "oldPrice": 25.99, "originalPrice": 25.99, "discountPercent": 38, "isOnSale": true },
        { "id": "M", "name": "M", "availability": "in_stock", "sku": 12345679, "price": 15.99, "oldPrice": 25.99, "originalPrice": 25.99, "discountPercent": 38, "isOnSale": true }
      ],
      "currency": "EUR",
      "price": 15.99,
      "oldPrice": 25.99,
      "originalPrice": 25.99,
      "discountPercent": 38,
      "isOnSale": true
    }
  ],
  "compositions": [
    { "part": "Outer shell", "materials": [{ "material": "Cotton", "percentage": "95%" }, { "material": "Elastane", "percentage": "5%" }] }
  ],
  "reviews": []
}
```

### Plan Requirement

The default proxy setting (Apify Proxy, automatic) serves the category tree, category listings, search results and product pages. The actor starts on your selected connection and only when a route is refused during a run, escalates to an Apify residential connection in the country of the market you chose, then to a backup connection. Residential access needs a paid Apify plan: Apify free plans do not include residential proxies, so on a free plan the run logs "The selected connection is unavailable to this run. Apify free plans do not include residential proxies." and continues on a backup connection where some pages may still be unavailable. If nothing loads you get a clear failure ("No results: residential proxies are unavailable on this run ...") rather than an empty success. If you supply your own proxy URLs, only those are used. Full detail is billed as a separate, optional per-product event (see the FAQ), so use **Max products total** and the filters to control the cost of any run.

### FAQ

#### How much does it cost?

You pay per product returned, plus an optional separate event for each product enriched with full detail (unit: one product; cadence: charged per product right after it is added to the dataset, never for products that were not delivered). The detail-enrichment event is charged one unit per product, right after that product is added to the dataset, so a run that stops early is only billed for the products already delivered. The **Pricing** tab shows the current rates. Use **Max products total** to cap the cost of any run.

#### Is it legal to scrape Zara?

This actor collects only publicly available product data. You are responsible for how you use it: follow Zara's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution. Product prices and descriptions are generally facts, but photos and brand names may be subject to third-party rights.

#### Why do some products come back with `compositions` and a size matrix, and others don't?

Those fields only fill in when **Fetch full product detail** is on, in which case every product left after filters and the cap is enriched. A pasted single product URL (`mode: "url"` with a product link) always fetches full detail regardless of that toggle, and is billed for it whenever the fetch actually returns composition data.

#### Why did a size filter return fewer products than I expected?

**Sizes** can only be checked once full detail has run, so it narrows the page after **Max products total** has already capped it, not the whole catalogue. Raise the cap, or set it to `0`, to check sizes across more of the catalogue.

#### Why did my run return zero products instead of failing?

A search-mode run needs a Category id and/or Rebajas only; leaving both empty returns no products, with a message in the log explaining why. Zara runs Rebajas seasonally: when no sale catalog is live for the chosen section (the site answers that the category does not exist), a Rebajas only run finishes empty with the log message "No Rebajas (sale) catalog is live for section=... right now" instead of failing as a block. Separately, if zara.com refuses every request during a run, the actor stops retrying and keeps whatever it already collected. When that leaves zero products (for example a pasted product link whose detail data is refused on every connection) the run ends as failed with a message saying nothing could be loaded, instead of a green empty run. Run it again in a few minutes if you suspect a block.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 Want more e-commerce data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>👗 <a href="https://apify.com/abotapi/mango-com-scraper"><b>Mango Scraper</b></a><br>Scrape Mango (shop.mango.com) fashion products: current price plus strike-through Rebajas...</td><td>🔌 <a href="https://apify.com/abotapi/fnac-com-scraper"><b>Fnac Scraper</b></a><br>Scrape Fnac (fnac.com) products: current price plus strike-through discount, colour/model...</td></tr>
<tr><td>🛒 <a href="https://apify.com/abotapi/uniqlo-com-scraper"><b>UNIQLO Scraper</b></a><br>Scrape UNIQLO products across 21 country storefronts in local currency. Price with pre...</td><td>🔌 <a href="https://apify.com/abotapi/boulanger-com-scraper"><b>Boulanger.com</b></a><br>Scrape Boulanger (boulanger.com) electronics and home-appliance products: current price...</td></tr>
<tr><td>🛒 <a href="https://apify.com/abotapi/druni-es-scraper"><b>druni.es</b></a><br>Scrape Druni beauty, cosmetics and perfume products. Search by keyword, category, Ofertas...</td><td>🛒 <a href="https://apify.com/abotapi/pccomponentes-com-scraper"><b>PcComponentes Scraper</b></a><br>Scrape PcComponentes (pccomponentes.com) products: current price plus strike-through...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/zara-com-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

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

'search' browses a category or Zara's own Rebajas (sale) catalog for a chosen section. 'url' scrapes any product or category/listing page URL you paste.

## `market` (type: `string`):

Zara's own market path prefix, e.g. 'es/es' (Spain, Castellano) or 'gb/en' (UK, English). Applies to search mode; a pasted URL in url mode carries its own market instead.

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

Which Zara section to browse. Drives the Rebajas catalog below and labels results; a Category id (also below) can point at any category in any section.

## `categoryId` (type: `string`):

A specific Zara category id to browse (any category, from any section). Find one by copying the number after '-l' from a category page's own URL and looking it up, or leave empty and use Rebajas only below. Ignored when Rebajas only is on. Search mode only: URL mode reads this from the link you paste.

## `specialsOnly` (type: `boolean`):

Browse the chosen section's own, real, currently-running Rebajas (sale) catalog instead of a specific category id -- verified live (thousands of items). Every returned product carries a genuine strike-through original price and discount percentage. Search mode only: URL mode reads this from the link you paste.

## `urls` (type: `array`):

Paste zara.com product pages, category/listing pages, keyword-search links (HTML or ajax=true), numeric category JSON links, category-tree links or products-details links, in any market. Left untouched it scrapes one example of each shape; an explicitly empty list fails the run. Search-mode fields are ignored here. The fields in the Filters section still apply, including to a pasted product URL.

## `productUrls` (type: `array`):

Same as URLs; accepts plain strings or {"url": ...} objects so an existing Zara Product Description input can be pasted unchanged. Ignored when URLs is set. Giving only this field switches to URL mode.

## `searchTerm` (type: `string`):

Only keep products whose name or description contains this text (case-insensitive). In search mode with no Category id and no Rebajas only, a plain word such as 'vestido' is matched against Zara category names and those categories are browsed. Otherwise in search mode it narrows the section or category catalog that is loaded; in URL mode it narrows the products found at the URL you paste. Applies in BOTH search mode and URL mode, including a pasted product URL.

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

Only keep products with at least one colourway matching one of these names (case-insensitive, partial match), e.g. 'negro', 'azul'. Applies in BOTH search mode and URL mode, including a pasted product URL.

## `sizes` (type: `array`):

Only keep products with at least one of these sizes in stock, e.g. 'S', 'M', '40'. Requires Fetch full detail below (per-size availability is only available with full detail) -- without it the run logs a warning and no product can match (a pasted product URL always has size data). It is applied AFTER the Max products cap, so fewer rows than the cap may come back. Applies in BOTH search mode and URL mode, including a pasted product URL.

## `minPrice` (type: `number`):

Only return products priced at or above this amount, in the market's own currency. Applies in BOTH search mode and URL mode, including a pasted product URL.

## `maxPrice` (type: `number`):

Only return products priced at or below this amount, in the market's own currency. Applies in BOTH search mode and URL mode, including a pasted product URL.

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

Order results after filtering. 'Relevance' keeps the catalog's own order. Applies in BOTH search mode and URL mode, including a pasted product URL.

## `fetchDetails` (type: `boolean`):

Adds the product description, fabric composition (material breakdown by percentage), family and state, first-visible date, related looks and a real per-size matrix (in stock / low on stock / out of stock, and each size's own price) for every colour. Current price, was-price/discount, and colour-level availability are already included without this toggle. A pasted product URL in url mode always fetches full detail regardless of this toggle.

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

Hard cap on total products returned across every search/URL entry. 0 = unlimited.

## `proxy` (type: `object`):

Connection settings for reaching zara.com. Starts on the selected connection and escalates to residential (paid Apify plan) or a backup connection when a route is refused. Free plans have no Apify proxy. Choose residential or your own proxy URLs to start there.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large pull without returning or charging for products already collected there. Use this after an interrupted run. For recurring daily monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns every matching product as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED products, which is how a price cut or a stock change is spotted. Turn on Emit unchanged or Emit expired only when you also want those rows returned (and billed). State is kept separately for each search, filter and detail setup; use State key to name or deliberately share a monitoring campaign. To continue one specific interrupted run instead, use Resume from a previous run above.

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently configured runs. Leave empty to let the actor derive a key automatically from the search, filters and detail settings, so different searches never mix state with each other.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return products that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have, so leave it off unless you want the full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return products that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search, so never when Max products capped it or when Resume was used. This returns, and bills, extra synthetic rows, so leave it off unless you need expiry tracking.

## `ignoreFieldsForChanges` (type: `array`):

Output field names that should NOT make a product count as UPDATED. Nothing is ignored by default. Add fields such as description or image if changes to them are not relevant to you. Use a dotted path (for example colors.images) to ignore a field inside a nested list. Ignored fields are still returned in the output.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify -> Settings -> Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON; the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "market": "es/es",
  "section": "WOMAN",
  "categoryId": "2420896",
  "specialsOnly": false,
  "urls": [
    "https://www.zara.com/es/es/mujer-vestidos-l1066.html",
    "https://www.zara.com/es/es/category/2420896/products?ajax=true",
    "https://www.zara.com/es/es/categories?ajax=true",
    "https://www.zara.com/es/es/search?searchTerm=vestido",
    "https://www.zara.com/es/es/search?searchTerm=vestido&ajax=true"
  ],
  "sortBy": "relevance",
  "fetchDetails": false,
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50
}
```

# Actor output Schema

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

No description

## `taxonomy` (type: `string`):

No description

## `colors` (type: `string`):

No description

## `detail` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "search",
    "market": "es/es",
    "categoryId": "2420896",
    "urls": [
        "https://www.zara.com/es/es/mujer-vestidos-l1066.html",
        "https://www.zara.com/es/es/category/2420896/products?ajax=true",
        "https://www.zara.com/es/es/categories?ajax=true",
        "https://www.zara.com/es/es/search?searchTerm=vestido",
        "https://www.zara.com/es/es/search?searchTerm=vestido&ajax=true"
    ],
    "proxy": {
        "useApifyProxy": true
    },
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "mode": "search",
    "market": "es/es",
    "categoryId": "2420896",
    "urls": [
        "https://www.zara.com/es/es/mujer-vestidos-l1066.html",
        "https://www.zara.com/es/es/category/2420896/products?ajax=true",
        "https://www.zara.com/es/es/categories?ajax=true",
        "https://www.zara.com/es/es/search?searchTerm=vestido",
        "https://www.zara.com/es/es/search?searchTerm=vestido&ajax=true",
    ],
    "proxy": { "useApifyProxy": True },
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/zara-com-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "market": "es/es",
  "categoryId": "2420896",
  "urls": [
    "https://www.zara.com/es/es/mujer-vestidos-l1066.html",
    "https://www.zara.com/es/es/category/2420896/products?ajax=true",
    "https://www.zara.com/es/es/categories?ajax=true",
    "https://www.zara.com/es/es/search?searchTerm=vestido",
    "https://www.zara.com/es/es/search?searchTerm=vestido&ajax=true"
  ],
  "proxy": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false
}' |
apify call abotapi/zara-com-scraper --silent --output-dataset

```

## MCP server setup

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