# Stark Scraper - Danish Builders Merchant Prices and EAN (`studio-amba/stark-scraper`) Actor

Scrape product data from stark.dk, the Danish builders merchant. Get prices with and without VAT, member prices, EAN barcodes, brands, stock status and category paths for every product variant.

- **URL**: https://apify.com/studio-amba/stark-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

## Stark Scraper

Pull product data from stark.dk, the Danish builders merchant. The actor returns one row per product variant with the price including and excluding VAT, the member price, EAN barcode, brand, supplier item number, stock status and category path.

Stark sells building materials, tools, workwear, paint, plumbing and garden supplies in Denmark. Each colour or size of a product is its own variant with its own number and EAN, and the actor returns each variant as a separate row.

### How to scrape Stark data

There are two ways to tell the actor which products to read.

1. Paste product pages into `productUrls`, for example `https://www.stark.dk/mascot-22581-983-customized-langaermet-t-shirt-hvid-5xl?id=2880-2320530`. The address must contain the `?id=` part, which names the variant.
2. Leave `productUrls` empty and fill `urlKeywords`. The actor reads the shop's public product list (the sitemap) and keeps variants whose address contains one of your words, for example `boremaskine`, `t-shirt` or `maling`. Words are lowercase, with `ae`, `oe` and `aa` in place of the Danish letters, as they appear in the product addresses.

The actor stops at `maxResults`. If you leave everything empty, it reads the first 50 variants in the product list.

Search result pages and category pages are not read. The actor only requests product pages and the sitemap files that robots.txt allows.

### Input

| Field | Type | Description |
|---|---|---|
| `productUrls` | list of URLs | Stark product pages that contain `?id=` |
| `urlKeywords` | list of words | Used when no URLs are given. Keeps variants whose address contains one of the words |
| `maxResults` | number | Maximum number of variants to return. Default 50 |
| `proxyConfiguration` | proxy | Apify Proxy settings. Default is Apify Proxy |

### What you get back

Each row is one product variant.

| Field | Description |
|---|---|
| `sku` | Stark variant number, the id in the product address |
| `productId` | Stark product id, shared by all variants of a product |
| `name` | Product name |
| `brand` | Brand |
| `ean` | EAN barcode of the variant |
| `supplierItemNumber` | Item number used by the manufacturer |
| `category` | Category path, top level first |
| `variantAttributes` | Attributes that define the variant, for example colour and size |
| `price` | Normal price in DKK including VAT |
| `priceExVat` | Normal price in DKK excluding VAT |
| `memberPrice` | Member price (Medlemspris) including VAT. Empty when Stark shows no lower member price |
| `memberPriceExVat` | Member price excluding VAT |
| `currency` | DKK |
| `priceUnit` | Unit the price applies to, for example STK |
| `inStock` | Whether the variant is sold online and not sold out |
| `soldOut` | True when Stark marks the variant as sold out or discontinued |
| `availableOnline` | Whether the variant can be ordered in the web shop |
| `restockDate` | Expected restock date, when Stark shows one |
| `description` | Product description as plain text |
| `imageUrl` | Main product image |
| `variantUrl` | Address of the variant |
| `url` | Product page that was read |
| `scrapedAt` | Time of the request |
| `country` | dk |
| `language` | da |

### Example output

```json
{
  "sku": "2660-2457469",
  "productId": "5-1687491",
  "name": "DEWALT DCD799N-XJ Slagboremaskine Solo 18V",
  "brand": "DEWALT",
  "ean": "5035048832554",
  "supplierItemNumber": "DCD799N-XJ",
  "category": "Værktøj & maskiner > Elværktøj > Boremaskiner",
  "variantAttributes": null,
  "price": 1580,
  "priceExVat": 1264,
  "memberPrice": null,
  "memberPriceExVat": null,
  "currency": "DKK",
  "priceUnit": "STK",
  "inStock": true,
  "soldOut": false,
  "availableOnline": true,
  "restockDate": null,
  "imageUrl": "https://media.starkgroup.structpim.com/747244.webp?width=1000",
  "country": "dk",
  "language": "da"
}
```

### Use cases

- Price monitoring: run the actor on a schedule with the same product addresses and compare `price` over time.
- Cross-shop matching: use `ean` to match Stark products against Bygma, Silvan, Bauhaus and other Danish and Nordic shops.
- Member price tracking: compare `price` with `memberPrice` to see how much Stark gives to members on each product.
- Assortment research: export a keyword such as `boremaskine` and look at brands, price spread and stock.
- Stock checks: track `inStock` and `soldOut` for products you resell or compare against.

### Cost and speed

The actor reads one page per variant over plain HTTP and needs no browser. Reading the product list takes a few seconds. Product pages are large, so about 50 variants take under a minute. Pricing is per result, see the pricing box on this page. The usage cost of a run only settles after the run reports SUCCEEDED, so a cost checked during the run is too low.

### Notes and limits

- The data covers stark.dk, the Danish shop. Prices are in Danish kroner.
- `price` is the normal public price including VAT. `priceExVat` is the same price without VAT.
- Stock is the online availability. Stock per Stark store is not part of the output.
- When you use `urlKeywords`, the actor reads at most three times `maxResults` addresses.
- Variants whose page no longer lists them are skipped and not charged.

### Frequently asked questions

#### Does it return EAN barcodes?

Yes. The `ean` field holds the barcode of each variant when Stark has one on file.

#### What is the member price?

Stark shows a lower Medlemspris next to the normal price for members. The actor returns it in `memberPrice` and leaves it empty when the page shows none.

#### Can I search by keyword?

Yes, with `urlKeywords`. The actor matches the words against the product addresses, which contain the product name. The shop's own search page is not used.

#### Why do I get several rows for one product?

Each colour and size is its own variant with its own number, price and EAN. Rows with the same `productId` belong to the same product.

#### How often can I run it?

As often as you like. For price monitoring, a daily run on the same list of product addresses works well.

### Related scrapers

- Gifi Scraper: discount home and leisure retail in France.
- Screwfix Scraper: trade supplies and tools in the UK.

# Actor input Schema

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

Product variant pages from stark.dk, for example https://www.stark.dk/mascot-22581-983-customized-langaermet-t-shirt-hvid-5xl?id=2880-2320530. The address must contain the ?id= part. Leave empty to read the shop's product list.

## `urlKeywords` (type: `array`):

Used when no product URLs are given. The actor reads the shop's product list and keeps variants whose URL contains one of these words, for example boremaskine or t-shirt. Words are lowercase, as in the product URLs, with ae, oe and aa for the Danish letters. Leave empty to read the first products in the list.

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

Maximum number of products to return.

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

Proxy used for the requests. Default is Apify Proxy.

## Actor input object example

```json
{
  "urlKeywords": [
    "boremaskine"
  ],
  "maxResults": 20,
  "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 = {
    "urlKeywords": [
        "boremaskine"
    ],
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/stark-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 = {
    "urlKeywords": ["boremaskine"],
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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