# About You Scraper — Fashion Products, Prices & Stock (`studio-amba/aboutyou-scraper`) Actor

Scrape product data from aboutyou.de, Germany's Zalando-scale multi-brand fashion marketplace. Extract names, brands, prices, sizes, stock status, and images via About You's own category page data.

- **URL**: https://apify.com/studio-amba/aboutyou-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **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/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

## About You Scraper

Pull product data from aboutyou.de, Germany's Zalando-scale multi-brand fashion marketplace — hundreds of brands, from Levi's and Tommy Hilfiger to smaller German labels, all in one storefront. This scraper reads the same structured data About You's own frontend renders into the page, so it returns clean, per-brand product records without fragile HTML scraping.

### How to scrape About You data

There are two ways in, and you can use either or both.

**By search term.** Give the actor a German search term (e.g. `"jeans"`, `"kleider"`, `"sneaker"`) and it resolves that term against About You's own category taxonomy (990+ women's, 458 kids', and hundreds of men's categories), then pulls product listings from every matching category page until it hits `maxResults`.

**By category URL.** Browse to a listing on aboutyou.de, set whatever filters you want, copy the URL out of the address bar and paste it into `categoryUrls`. The actor scrapes exactly that listing — see [Category URLs](#category-urls) below.

Set both and the actor runs both, deduplicated by product ID against one shared `maxResults` budget. Set neither and it defaults to searching for `"kleider"` (dresses) as a demo. No login and no cookies are needed either way.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Search term, in German (e.g. `"jeans"`, `"kleider"`, `"sneaker"`, `"jacke"`) |
| `categoryUrls` | array | Up to 50 About You category listing URLs, filters included — see [Category URLs](#category-urls) |
| `maxResults` | integer | Cap on number of products returned across search terms and category URLs combined (default: 100) |
| `fetchDetails` | boolean | Off by default. Fetch each product's own page for material, fit, functionality and the product description — see [Product detail mode](#product-detail-mode) below |
| `maxDetailFetches` | integer | Cap on detail-page fetches per run when `fetchDetails` is on (default: 500) |
| `proxyConfiguration` | object | Apify proxy settings. About You's category pages have no anti-bot protection, so the default Apify proxy is sufficient — no residential proxy needed. If you set a specific proxy country, the actor automatically switches to residential proxies for it, since Apify's default proxy pool does not have IPs in every country (including Germany itself) |

### What you get back

| Field | Type | Example |
|-------|------|---------|
| `name` | string | `"OBJECT Blusenkleid 'OBJSANNE'"` |
| `brand` | string | `"OBJECT"` |
| `price` | number | null | `19.16` |
| `originalPrice` | number | null | `47.90` (only set when the item is discounted) |
| `currency` | string | `"EUR"` |
| `discount` | string | null | `"-70%"` |
| `sku` | string | `"31737256"` |
| `productId` | string | `"31737256"` |
| `inStock` | boolean | null | `true` (null only if the source omits stock data) |
| `url` | string | Full product page URL |
| `imageUrl` | string | Primary product image |
| `imageUrls` | array | All product images |
| `category` | string | null | `"Kleider"` |
| `sizes` | array | Sizes with stock, filled when `fetchDetails` is on: `[{"size": "38", "inStock": true}, {"size": "42", "inStock": false}]` |
| `scrapedAt` | string | ISO timestamp |

With `fetchDetails` on, each item also gets `attributes`, `features`, `productDescription`, `material`, `articleNumber`, `detailsFetched` and `detailUrl` — see [Product detail mode](#product-detail-mode).

### Sample output

```json
{
  "name": "OBJECT Blusenkleid 'OBJSANNE'",
  "brand": "OBJECT",
  "price": 19.16,
  "originalPrice": 47.9,
  "currency": "EUR",
  "discount": "-70%",
  "sku": "31737256",
  "productId": "31737256",
  "inStock": true,
  "url": "https://www.aboutyou.de/p/object/blusenkleid-objsanne-31737256",
  "imageUrl": "https://cdn.aboutstatic.com/file/images/fdbcaa4f50269981a0f9d5dd9c9a932f.jpg?quality=75",
  "imageUrls": [
    "https://cdn.aboutstatic.com/file/images/fdbcaa4f50269981a0f9d5dd9c9a932f.jpg?quality=75",
    "https://cdn.aboutstatic.com/file/images/558af7e605204a921f0b64e2bf231f99.png?bg=F4F4F5&quality=75&trim=1"
  ],
  "category": "Kleider",
  "sizes": [
    { "size": "34", "inStock": true },
    { "size": "36", "inStock": true },
    { "size": "38", "inStock": true }
  ],
  "scrapedAt": "2026-08-29T15:12:09.238Z"
}
```

### Category URLs

Paste listing URLs from aboutyou.de into `categoryUrls` to scrape those exact listings. Everything in the query string is respected, so whatever you filtered down to on the site is what you get back.

```json
{
  "categoryUrls": [
    "https://www.aboutyou.de/c/frauen/bekleidung/jeans-20258",
    "https://www.aboutyou.de/c/frauen/bekleidung-20204?brand=levi-s-226",
    "https://www.aboutyou.de/c/maenner/schuhe/sneaker-20399?color=38919"
  ],
  "maxResults": 200
}
```

What counts as a category URL:

- Category listings: `/c/frauen/bekleidung/jeans-20258`
- Brand listings: `/b/shop/levi-s-226`
- Filtered listings: any of the above with About You's own filter parameters (`?brand=`, `?color=`, `?categoryShopFilterSizes=`, `?hasCampaignReduction=true`, and so on)
- Bare paths work too — `/c/frauen/bekleidung-20204` is accepted without the domain

Product pages (`/p/...`) are single products, not listings, and are skipped with a warning. So are URLs from other sites. Up to 50 URLs per run; `maxResults` is the cap across all of them combined, and products are deduplicated by product ID, so overlapping URLs never produce duplicate rows.

`page=` is dropped from any URL you supply. About You's edge strips it before the request reaches their application, so it does nothing — the actor pages through a listing by scrolling it, the same way the site does.

Category URLs and `searchQuery` are independent. Give one, the other, or both. `fetchDetails` applies to products from either source.

### Product detail mode

Off by default (`fetchDetails: false`). Turn it on to also pull each product's own page for the specifications About You lists in its product accordions: material and care, size and fit, functionality, the feature bullets under "Design & Extras", and the product description.

This costs one extra page request per product on top of the category pages. Each product detail page fetched is charged as a separate event, `product-detail-fetch`, at $0.004. A 100-product run with the mode on therefore adds $0.40 to the run's result and start fees. It also takes longer: the actor reads each product from the same product data call About You's own product page makes, several at a time, so budget roughly half a second per product on top of the listing crawl (a 60-product run with details took 70 seconds on 20 October 2026). If that call fails, the actor falls back to the product page, and to a headless browser when About You serves product pages only to browsers. Budget 5 to 20 seconds per product then; the price per detail page does not change.

`maxDetailFetches` (default 500) caps how many detail pages a single run fetches, regardless of `maxResults`. Products past the cap are still returned with their listing data, with `detailsFetched` set to `false` and the attribute fields empty, so you can always tell a capped product from one that genuinely has no attributes.

Each item gets:

| Field | Type | Description |
|-------|------|-------------|
| `attributes` | object | null | Specifications keyed by a slug of About You's own accordion section (`groesse_fit`, `material_pflege`, `funktionalitaet`, ...), each an object of the site's original German label/value pairs. Null when the detail page was fetched but carried no specifications |
| `features` | array | Unlabelled feature bullets from "Design & Extras" (`"Unifarben"`, `"5-Pocket-Style"`, `"30 °C Wäsche"`) |
| `productDescription` | string | null | The product page's own free-text description |
| `material` | string | null | Flattened from the material section's `Obermaterial` or `Material` key |
| `articleNumber` | string | null | The product page's `Art.-Nr.` value |
| `detailsFetched` | boolean | True only when the detail page was fetched and attributes were parsed |
| `detailUrl` | string | The product page a detail fetch was (or would have been) attempted against |

Example input:

```json
{
  "searchQuery": "jeans",
  "maxResults": 20,
  "fetchDetails": true,
  "maxDetailFetches": 20
}
```

The extra fields on a returned item:

```json
{
  "attributes": {
    "groesse_fit": {
      "Länge": "Lang/Maxi",
      "Hosenschnitt": "Loosefit",
      "Leibhöhe": "Mid Waist"
    },
    "material_pflege": {
      "Material": "100% Baumwolle"
    }
  },
  "features": [
    "Unifarben",
    "Light washed",
    "5-Pocket-Style",
    "Gürtelschlaufen",
    "30 °C Wäsche"
  ],
  "productDescription": "Big jeans were synonymous with the nineties, but no matter the decade, it's been proven that these '94 Wide-Leg Moto jeans will never go out of style.",
  "material": "100% Baumwolle",
  "articleNumber": "LEV5162007000015",
  "detailsFetched": true,
  "detailUrl": "https://www.aboutyou.de/p/levi-s/jeans-94-baggy-19229314"
}
```

Which sections a product carries depends on what its brand supplied. Apparel typically has size/fit and material sections, footwear adds functionality. Labels stay in German, exactly as About You publishes them, so a value is never lost to a translation guess.

### Use cases

- **Price monitoring** — track About You's own price and discount changes across the many brands it resells.
- **Multi-brand assortment research** — see which brands show up under a given search term, and at what price points, across a Zalando-scale marketplace.
- **Discount tracking** — `originalPrice` and `discount` surface active markdowns as they happen.
- **Market comparison** — About You aggregates hundreds of brands under one storefront, making it a useful single reference point when benchmarking German fashion pricing against brand-direct sites.

### Coverage

v1 defaults to women's categories (About You's own flagship landing segment), but the search-term matcher works against the site's full category tree, which also covers men's and kids' apparel — a men's or kids'-specific search term (e.g. `"herrenjacke"`) will still resolve correctly.

About You's category pages load more products as you scroll rather than through numbered pages, so the scraper scrolls each listing to pull in products, then moves on to the next one and deduplicates by product ID (e.g. a search for `"kleider"` pulls from the general dresses category, the sale dresses category, the premium dresses category, and so on). Broader search terms that match many narrow sub-categories return more unique products per run than very specific ones.

### Performance and cost

The scraper reads the first 30 products of a listing straight from the page HTML, which takes about a second and needs no browser at all. Only when a run wants more than that from the same listing does it load the page in a headless browser and scroll it, which is how it pages past 30. A run of 20 products from one category URL therefore finishes in seconds; a 100-product run takes a couple of minutes.

This actor charges $0.02 per run (start fee, based on its 4 GB memory allocation) plus $0.002 per result — a 100-product run costs about $0.22. With `fetchDetails` on, add $0.004 per detail page. Your run's usage cost only settles after the run reports SUCCEEDED — checking cost mid-run will undercount it.

### Limitations

- `sizes` comes from the product page, so it is filled only when `fetchDetails` is on. Each size says whether it can be ordered (`inStock`). There are no per-size quantities. The listing pages carry no size list.
- No separate EAN/barcode field — `sku` and `productId` are the same internal About You product ID.
- No rating or review data — not exposed by the category listing endpoint this actor reads.
- Search is keyword-based, matching About You's own category structure. It does not accept direct product URLs or free-text full-site search (About You's `/search` endpoint is excluded by the site's own `robots.txt`).
- `categoryUrls` takes listing URLs only. Product URLs (`/p/...`) are rejected — use `searchQuery` or a category URL to find the products, then turn on `fetchDetails` for their full specifications.
- A single listing scrolls to roughly 180 products before About You stops feeding the grid. For deeper coverage of a large category, split it into its sub-categories or filtered variants and pass several URLs.

### Related scrapers

If you're covering German fashion retail more broadly, also check out:

- [C\&A Scraper](https://apify.com/studio-amba/c-and-a-scraper) — major European fashion chain with per-size stock data
- [Deichmann Scraper](https://apify.com/studio-amba/deichmann-scraper) — Europe's largest shoe retailer
- [Intersport Scraper](https://apify.com/studio-amba/intersport-scraper) — German sporting goods and athletic footwear
- [New Yorker Scraper](https://apify.com/studio-amba/newyorker-scraper) — German youth/streetwear fashion chain

### Support

Found an issue or need a different locale covered? Open an issue on this actor's Apify Store page and we'll take a look.

# Actor input Schema

## `searchQuery` (type: `string`):

Search term to find products on aboutyou.de (German, e.g. "kleider", "jeans", "sneaker"). Matched against About You's own category taxonomy.

## `categoryUrls` (type: `array`):

Scrape specific About You category listings instead of searching. Paste full category URLs straight from the site, filters included, e.g. "https://www.aboutyou.de/c/frauen/bekleidung-20204" or "https://www.aboutyou.de/c/frauen/bekleidung-20204?brand=levi-s-226". Brand listings (/b/shop/...) work too. Filters in the query string are respected. Product pages (/p/...) are not category listings and are skipped with a warning. Up to 50 URLs per run. Leave this empty to use Search Query instead; set both and the actor scrapes both, deduplicated by product ID and sharing the same Max Results budget.

## `maxResults` (type: `integer`):

Maximum number of products to scrape

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

Fetch each product's own page for material, fit, functionality and other specifications (attributes), plus the product description. Off by default. Costs ONE EXTRA page request per product on top of the category page renders, and is billed as a separate 'product detail page' event at $0.004 per product. Use the cap below to control the spend on large runs.

## `maxDetailFetches` (type: `integer`):

Hard cap on how many product detail pages this run will fetch when "Fetch product detail attributes" is on. Protects against accidentally launching thousands of extra requests on a large maxResults run. Products past the cap are still returned, with their attribute fields empty and detailsFetched set to false. Ignored when fetchDetails is off.

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

Apify proxy configuration. About You's category pages have no anti-bot protection (verified live), so the default Apify proxy is sufficient. If you set a specific proxy country, the actor automatically switches to residential proxies for it, since Apify's default proxy pool does not have IPs in every country.

## Actor input object example

```json
{
  "searchQuery": "kleider",
  "maxResults": 100,
  "fetchDetails": false,
  "maxDetailFetches": 500,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchQuery": "kleider",
    "maxResults": 100,
    "fetchDetails": false,
    "maxDetailFetches": 500,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/aboutyou-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 = {
    "searchQuery": "kleider",
    "maxResults": 100,
    "fetchDetails": False,
    "maxDetailFetches": 500,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/aboutyou-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 '{
  "searchQuery": "kleider",
  "maxResults": 100,
  "fetchDetails": false,
  "maxDetailFetches": 500,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/aboutyou-scraper --silent --output-dataset

```

## MCP server setup

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