# Loewe Scraper — Style Codes, Prices & Stock (`studio-amba/loewe-scraper`) Actor

Scrape Loewe.com's full EU product sitemap for style codes, prices, per-size availability and images, straight from the brand — no login, no anti-bot wall found.

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

## Pricing

from $1.20 / 1,000 result 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/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.

- **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

## Loewe Scraper

Scrape Loewe.com's entire EU product catalog — style codes, prices,
per-size stock and images — straight from the brand's own product
sitemap.

### Why use this actor?

Luxury products have no EAN or UPC. The only reliable way to match the
same Loewe bag, jacket or pair of sunglasses across retailers, resale
platforms, or your own inventory is the brand's own style code (e.g.
`A03918MX01-1100`). This actor harvests that code, plus current price,
per-size availability and images, for the entire catalog in one run — no
manual browsing, no login, and no per-product lookups needed.

### How to scrape Loewe data

1. Leave the input empty (`{}`) to harvest the full eur/en product
   sitemap — roughly 2,270 products, measured live 2026-08-13.
2. Or set `maxItems` to cap the run, or pass specific `startUrls` (product
   page URLs) to scrape a known list instead of the full catalog.
3. Run the actor. Each result is one product: name, brand, normalized
   style code, price in EUR, availability, per-size stock ladder where
   applicable, main image, and the product URL.
4. Export the dataset as JSON, CSV, or Excel from the Apify Console, or
   pull it via the API.

Loewe.com's product pages are open to a plain HTTP request — no login and
no JavaScript rendering needed. The actor reads
`https://www.loewe.com/eur/sitemap_0-product.xml` and
`.../sitemap_1-product.xml` (discovered via `robots.txt` →
`eur/en/sitemap_index.xml`), filters to `/eur/en/` product URLs, then
reads each product page's own embedded product data for the fields.
Loewe runs a Salesforce Commerce Cloud storefront on the Mobify PWA Kit —
a React-rendered page rather than the plain JSON-LD markup other
brand-direct actors in this family (Prada, Miu Miu, Chloé, Off-White,
Burberry) use, so this actor reads the site's own React Query data cache
instead.

### Input

| Field | Type | Required | Description |
|-------|------|----------|--------------|
| `startUrls` | Array | No | Specific Loewe product page URLs to scrape instead of the full sitemap. |
| `maxItems` | Integer | No | Stop after this many products. `0` or empty means harvest the entire sitemap (~2,270 products). |
| `maxConcurrency` | Integer | No | Parallel page requests (default: 15). |
| `proxyConfiguration` | Object | No | Apify Proxy settings. No country pin needed — the actor sends its own language/currency cookie on every request, so pricing and product text stay English/EUR regardless of proxy exit. |

### Output

Each result is one product:

| Field | Type | Example |
|-------|------|---------|
| `brand` | String | `"Loewe"` |
| `productName` | String | `"Medium Amazona 180 bag in soft calfskin"` |
| `styleCode` | String | `"A03918MX011100"` (normalized: uppercase, alphanumeric only) |
| `styleCodeRaw` | String | `"A03918MX01-1100"` (as printed on the site) |
| `styleCodeLength` | Number | `14` |
| `styleCodeIsFull` | Boolean | `true` — read from the PDP's own product data |
| `price` | Number | `3900` |
| `currency` | String | `"EUR"` |
| `availability` | Boolean/null | `true` — nullable 3-state, never coerced to `false` when unknown |
| `sizes` | Array | Per-size stock ladder, e.g. `[{"size":"36","sku":"3625","inStock":true}, ...]` — only present for clothing/belts, absent for one-size items like bags |
| `color` | String | `"Black"` |
| `description` | String | Loewe's own product description (absent, not empty-padded, on the rare bundle products that don't carry one) |
| `imageUrl` | String | Main product image URL, resolved to absolute |
| `productUrl` | String | Loewe.com product page URL |
| `isPreOwned` | Boolean | `false` — always, this is a first-party brand listing |
| `source` | String | `"loewe.com"` |
| `scrapedAt` | String | ISO 8601 timestamp |

### Example output

Real output from a live run:

```json
{
    "brand": "Loewe",
    "productName": "Medium Amazona 180 bag in soft calfskin",
    "styleCode": "A03918MX011100",
    "styleCodeRaw": "A03918MX01-1100",
    "styleCodeLength": 14,
    "styleCodeIsFull": true,
    "price": 3900,
    "currency": "EUR",
    "availability": true,
    "color": "Black",
    "description": "The Amazona 180 revisits one of LOEWE's most storied bags, taking on a relaxed silhouette anchored by a single toron top handle...",
    "imageUrl": "https://www.loewe.com/dw/image/v2/BBPC_PRD/on/demandware.static/-/Sites-Loewe_master/default/dwb2f71987/images_rd/A03918MX01/A03918MX01-1100/A03918MX01_1100_1F.jpg?sw=500&q=100",
    "productUrl": "https://www.loewe.com/eur/en/women/bags/amazona/medium-amazona-180-bag-in-soft-calfskin/A03918MX01-1100.html",
    "isPreOwned": false,
    "source": "loewe.com",
    "scrapedAt": "2026-08-13T10:02:18.273Z"
}
```

### Cost estimate

This actor makes one lightweight HTTP request per product — no browser
rendering. At the MID pricing tier ($0.002 per result + $0.005 per run),
scraping 1,000 products costs roughly **$2.01** in platform fees plus your
Apify compute usage, which is minimal since every request is plain
HTTP/Cheerio. Usage cost only settles after the run reports SUCCEEDED —
reading the dataset mid-run undercounts what you'll actually be charged.

### Limitations

- Per-size stock is only available for products that have a size
  dimension (clothing, belts) — bags, sunglasses and other one-size items
  don't carry a `sizes` array, matching how Loewe itself doesn't offer a
  size picker on those product types.
- Currency is fixed at EUR because this actor reads the eur/en storefront
  sitemap specifically. Loewe dispatches both currency AND display
  language by request geo-IP (a non-English proxy exit can silently
  redirect an `/eur/en/...` URL and render the whole page in the local
  language) — this actor pre-sends the site's own language-preference
  cookie on every request so results stay English/EUR regardless of which
  country the proxy exits from.
- A small minority of products are customisable "set"/bundle items (e.g.
  charm sets) with no size/stock data at all — `availability` is left
  `null` rather than guessed, and `description` is omitted rather than
  shipped empty.
- If a product page is ever blocked or returns something unexpected, the
  record still gets pushed with the style code read straight from the URL
  slug — price, availability and image are left `null` rather than the
  run failing outright.
- Data is scraped from the public Loewe.com site and may change without
  notice if Loewe changes its markup or sitemap structure.
- Respect Loewe's terms of service and use the data responsibly.

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API — maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

### Related Scrapers

- [Prada Scraper](https://apify.com/studioamba/prada-scraper) — Same
  brand-direct sitemap pattern for Prada.com.
- [Miu Miu Scraper](https://apify.com/studioamba/miu-miu-scraper) — Same
  Prada Group platform and pattern, for MiuMiu.com.
- [Burberry Scraper](https://apify.com/studioamba/burberry-scraper) — Same
  pattern for Burberry.com, with exact per-size stock quantities.
- [Off-White Scraper](https://apify.com/studioamba/off-white-scraper) —
  Same brand-direct pattern for Off---White.com.
- [Chloé Scraper](https://apify.com/studioamba/chloe-scraper) — Same
  pattern for Chloe.com.

# Actor input Schema

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

Optional: specific Loewe product page URLs to scrape instead of the full sitemap, e.g. https://www.loewe.com/eur/en/women/bags/amazona/medium-amazona-180-bag-in-soft-calfskin/A03918MX01-1100.html

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

Stop after this many products. Leave empty (or 0) to harvest the entire eur/en product sitemap (~2,270 products, measured 2026-08-13).

## `maxConcurrency` (type: `integer`):

Parallel page requests. Lower this if you see errors.

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

Loewe.com's product pages are open to plain GET (verified 2026-08-13, no anti-bot wall). No country pin is needed — the actor sends its own language/currency cookie on every request, so any proxy exit returns English/EUR content.

## Actor input object example

```json
{
  "maxItems": 20,
  "maxConcurrency": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 20,
    "maxConcurrency": 15,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/loewe-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 = {
    "maxItems": 20,
    "maxConcurrency": 15,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/loewe-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 '{
  "maxItems": 20,
  "maxConcurrency": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/loewe-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/loewe-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/qDksAp54Yx0Q6CJMl/builds/HMnZL4ezcZvEX6GP9/openapi.json