# de Bijenkorf Product & Price Scraper (`getascraper/debijenkorf-scraper`) Actor

Scrape de Bijenkorf products: live and original prices, discount percentages, full size and colour stock levels, brand, categories, and image galleries. Get one clean row per product with every variant nested, ready for your spreadsheet. No login needed.

- **URL**: https://apify.com/getascraper/debijenkorf-scraper.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.13 / 1,000 product records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## de Bijenkorf scraper

Get de Bijenkorf product data: live sale prices, original prices and discount percentages, full size and colour stock levels, and image galleries, ready for your spreadsheet in minutes.

**de Bijenkorf** is the leading premium department store in the Netherlands and Belgium, carrying designer fashion, beauty, and homeware. This scraper turns any de Bijenkorf category page or product page into clean, structured rows you can open in Excel, Google Sheets, or your own database. It captures the full size and colour matrix for every product, so you see the price and stock of each individual variant, not just the headline item.

### What does de Bijenkorf scraper do?

You give it category links or individual product links. It returns one clean row per product, plus a nested breakdown of every size and colour variant. For each product you get the current sale price, the original price before discount, the exact discount percentage, live stock counts, brand, category path, and the full image gallery. Empty fields are left blank rather than filled with guesses, so the data stays trustworthy.

### Why use de Bijenkorf scraper?

Pricing analysts, brand managers, and online retailers need accurate, current catalogue data to make decisions. This scraper supports:

* **Sale and discount monitoring:** Track current price against original price and the discount percentage to map seasonal markdowns and promotional cycles.
* **Variant-level stock intelligence:** See the live stock count of every size and colour, so you can spot fast-selling variants and predict stock-outs.
* **Assortment and pricing benchmarking:** Compare designer brands, categories, colours, and prices to position your own range.

### Who is this for?

* **I am a competitor pricing analyst** tracking how a premium department store discounts designer fashion week over week, so I can match or undercut key items in my own store.
* **I am a brand manager** monitoring how my products are priced and stocked across sizes and colours on a major retail partner, so I can flag stock-outs and pricing errors fast.
* **I am an online fashion retailer** building a price and availability feed of thousands of products, so I can benchmark my assortment against the market without checking pages by hand.
* **I am a market researcher** studying discount depth and stock patterns across categories, so I can report on retail demand and seasonal trends.

### How to use de Bijenkorf scraper

1. **Add your links:** Paste de Bijenkorf category pages or individual product pages into the input form.
2. **Set a limit:** Set the maximum number of products to control run time and budget.
3. **Run it:** Start the scraper and watch clean rows arrive in your dataset in real time.
4. **Download:** Export your results as Excel, CSV, JSON, or XML.

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `startUrls` | array of URLs | Yes | de Bijenkorf category pages or individual product pages to scrape. The scraper reads product links from category pages automatically. |
| `maxItems` | integer | No | Maximum number of products to save in one run. Use it to cap your run time and budget. Defaults to 100. |
| `proxyConfiguration` | object | No | Proxy settings. Defaults to fast, low-cost datacenter proxies, which work for both category and product pages. Residential is available for very large runs. |

### Output

Each product becomes one row, with every size and colour variant nested inside the `variants` field.

**Example output**

```json
{
  "product_id": "4047070054",
  "name": "Brushstroke T-shirt met logo- en backprint",
  "display_name": "OLAF Brushstroke T-shirt met logo- en backprint",
  "brand": "OLAF",
  "price": 52.5,
  "original_price": 75,
  "discount_percentage": 30,
  "on_sale": true,
  "currency": "EUR",
  "in_stock": true,
  "stock_count": 21,
  "delivery_time": "NEXT_DAY",
  "size": "XS",
  "color": "Wit",
  "color_count": 2,
  "categories": ["T-shirts"],
  "category_path": "Heren > Kleding > Polo's & T-shirts > T-shirts",
  "variants": [
    { "variant_code": "404707005411000", "size": "S", "color": "Wit", "price": 52.5, "original_price": 75, "currency": "EUR", "in_stock": true, "stock_count": 16, "delivery_time": "NEXT_DAY" }
  ],
  "image_url": "https://cdn-1.debijenkorf.nl/default/olaf-brushstroke-t-shirt/front.jpg",
  "image_gallery": ["https://cdn-1.debijenkorf.nl/default/olaf-brushstroke-t-shirt/front.jpg"],
  "product_url": "https://www.debijenkorf.nl/d/olaf-brushstroke-t-shirt-4047070054",
  "scraped_at": "2026-06-28T14:33:00.000Z"
}
````

### Data table

| Field | Type | Description |
| --- | --- | --- |
| `product_id` | string | Unique product code. |
| `variant_code` | string | Code of the specific size and colour variant shown in the main row. |
| `name` | string | Product name. |
| `display_name` | string | Full product name including the brand. |
| `description` | string | Product description with formatting removed. |
| `brand` | string | Brand or designer name. |
| `price` | number | Current selling price. |
| `original_price` | number | Original price before any discount. |
| `discount_percentage` | number | Percentage off, from original price to current price. |
| `on_sale` | boolean | True when the current price is below the original price. |
| `currency` | string | Three letter currency code, such as EUR. |
| `in_stock` | boolean | True when the product is available to buy. |
| `stock_count` | number | Units in stock for the main variant. |
| `delivery_time` | string | Delivery window, such as NEXT\_DAY. |
| `size` | string | Size of the main variant. |
| `color` | string | Colour of the main variant. |
| `color_count` | number | Number of colours the product is available in. |
| `categories` | array of strings | Category names the product belongs to. |
| `category_path` | string | Full category breadcrumb path. |
| `variants` | array of objects | Every size and colour, each with its own price, original price, stock count, and delivery time. |
| `ingredients` | string | Ingredient list for beauty products, when shown. |
| `composition` | string | Material or composition detail, when shown. |
| `image_url` | string | Main product image. |
| `image_gallery` | array of strings | All product images. |
| `product_url` | string | Direct link to the product page. |
| `scraped_at` | string | Timestamp of when the row was collected. |

### Pricing

This scraper uses pay per result billing. You are charged only for product rows successfully saved to your dataset. Empty runs and blocked requests cost nothing. There are no monthly subscriptions and no fixed fees. Set a `maxItems` value to keep every run within budget.

### FAQ, disclaimers, and support

##### Does it get blocked?

No. The scraper handles de Bijenkorf's security checks automatically and retries when needed, so runs complete reliably without any setup from you.

##### Do I need a de Bijenkorf account?

No. It collects only publicly visible catalogue listings. You never need to register, log in, or supply any cookies.

##### Does it cover both Netherlands and Belgium?

Yes. It works across the Netherlands (`debijenkorf.nl`) and Belgium (`debijenkorf.be`) sites. Paste links from either and the scraper handles both.

##### How fresh is the data?

Every row is collected live at the moment you run the scraper. There is no cached or stale data.

##### Why is a field sometimes empty?

Not every product lists every detail. When a value is genuinely missing, the field is left blank rather than filled with a placeholder, so your data stays accurate.

### Legal

This scraper collects only data that is publicly visible on de Bijenkorf. It does not access private accounts or bypass any login. Users are responsible for complying with local regulations and the website's terms of service. de Bijenkorf is a trademark of its owner. This is an independent tool and is not affiliated with, endorsed by, or sponsored by de Bijenkorf.

### Support

Open an issue on the Issues tab for any bug, question, or feature request. We respond within 48 hours.

# Actor input Schema

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

Add de Bijenkorf category listing or direct product URLs.

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

Maximum number of unique product models to extract across this run.

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

Proxy settings. Datacenter proxies (the default) are fast and cheap — the headless browser solves de Bijenkorf's Cloudflare challenge on datacenter IPs, verified end-to-end. Switch to Residential only if a very large run starts hitting rate limits. The locale is set by the URL and the API's locale=nl\_NL parameter, so no country filter is needed.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.debijenkorf.nl/herenmode/polo-s-t-shirts/t-shirts"
    }
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "startUrls": [
        {
            "url": "https://www.debijenkorf.nl/herenmode/polo-s-t-shirts/t-shirts"
        }
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/debijenkorf-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.debijenkorf.nl/herenmode/polo-s-t-shirts/t-shirts" }],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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.debijenkorf.nl/herenmode/polo-s-t-shirts/t-shirts"
    }
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call getascraper/debijenkorf-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=getascraper/debijenkorf-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "de Bijenkorf Product & Price Scraper",
        "description": "Scrape de Bijenkorf products: live and original prices, discount percentages, full size and colour stock levels, brand, categories, and image galleries. Get one clean row per product with every variant nested, ready for your spreadsheet. No login needed.",
        "version": "0.1",
        "x-build-id": "NjGtmIGFLoJRnD4jp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~debijenkorf-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-debijenkorf-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/getascraper~debijenkorf-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-debijenkorf-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/getascraper~debijenkorf-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-debijenkorf-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Bijenkorf Category or Product URLs",
                        "type": "array",
                        "description": "Add de Bijenkorf category listing or direct product URLs.",
                        "default": [
                            {
                                "url": "https://www.debijenkorf.nl/herenmode/polo-s-t-shirts/t-shirts"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Product Limit",
                        "minimum": 1,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Maximum number of unique product models to extract across this run.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Datacenter proxies (the default) are fast and cheap — the headless browser solves de Bijenkorf's Cloudflare challenge on datacenter IPs, verified end-to-end. Switch to Residential only if a very large run starts hitting rate limits. The locale is set by the URL and the API's locale=nl_NL parameter, so no country filter is needed.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
