# Matas Price Monitor - Beauty prices for Denmark (`mmdincer/matas-product-price-monitor`) Actor

Watches public Matas product pages and records the price and availability. Returns the product name, SKU, price, currency, and stock state. One run accepts up to five https://www.matas.dk product URLs. Results as JSON, CSV or Excel. Access through API or MCP.

- **URL**: https://apify.com/mmdincer/matas-product-price-monitor.md
- **Developed by:** [Muhammet Mustafa Dincer](https://apify.com/mmdincer) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 product checkeds

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

> 💼 Looking for another beauty price watch instead? 👉 [Lyko Price Monitor - Beauty product prices for Sweden](https://apify.com/mmdincer/lyko-product-price-monitor)

### 🤖 What does Matas do?

Matas reads a public product page and keeps the price and the availability. The source is www.matas.dk. The first saved reading is a baseline. A later run compares the new reading with that baseline.

It can scrape:

- **Public Matas product pages** you paste, up to five in one run
- **The name, SKU, price, currency, and availability** printed in Product JSON-LD, or in the public product detail on that same page when the JSON-LD block has no price
- **A later change** when the saved price or availability is different

Matas does not search the catalogue. Matas does not log in. Matas does not ask for an API key. A row stores the URL, the product name, the SKU, the GTIN-13 when the page prints one, the price, the currency, and the availability. The description, the images, reviews, and a person's name are not stored.

The sample page is `https://www.matas.dk/vichy-mineral-89-booster-50-ml`. On 11 November 2026 that page showed 239.95 DKK and InStoreOnly for Vichy Minéral 89 Booster 50 ml, SKU 769170. InStoreOnly is the availability the page printed. It is a real stock state, not an empty row. A later run stores the price and availability the page shows then. Do not treat that figure as a permanent Matas value.

### 💡 Why scrape Matas?

People scrape Matas when the same public page would otherwise be opened by hand. The fields support a price check, a stock check, and a change log. They do not support a review export or a full catalogue dump.

- Watch one Matas product on a schedule and keep the reading.
- Feed a sheet. The dataset opens as JSON, CSV, or Excel.
- Call Matas from the Apify API with the same input.
- Hand the same input to an agent through Apify MCP.
- Start from the prefilled Matas sample, which is one real product URL.

Matas is for the URL you already have. It is not a site search, and it does not walk category pages.

### 🚀 How to scrape Matas

1. Click **Try for free**.
2. Keep the prefilled product URL, or paste up to five `www.matas.dk` product URLs.
3. Leave **Only changes** off for the sample so a repeated run still writes the current reading. The schema default is on, and the prefill is off.
4. Leave the watchlist name as `default`, or type another name when this list should not share the old baseline.
5. Click **Run**. Download the dataset as JSON, CSV, or Excel.

```json
{
  "productUrls": [
    "https://www.matas.dk/vichy-mineral-89-booster-50-ml"
  ],
  "onlyChanges": false,
  "monitorName": "default"
}
```

A second run with the same input writes the current Matas reading again while only changes stays off. Turn only changes on after a baseline exists when a quiet check should add a row only if the saved reading moved. A first read is still written.

### ⚠️ Limits

Matas enforces the limits below. Anything not listed is not a limit this code applies.

- The path must be one https://www.matas.dk product URL. Home, search, account, cart, and checkout URLs are rejected. The price is read from Product JSON-LD, including a ProductGroup variant when that is where the page puts the Product. When that block has no price, the public product detail on the same page is read.
- At most five URLs per run. A duplicate URL is skipped.
- The query string is removed, so a tracking parameter is not a second product.
- Requests are one at a time. The HTTP timeout is 30 seconds.
- HTTP 403 is an error and is not retried. HTTP 429 stops further products. A challenge page with no public price is not bypassed. A redirect onto a path robots.txt disallows is not stored.
- A page with no public price is `no_data` and is not charged.
- If the maximum charge cannot cover a check, the page is not requested. If a change cannot be covered, the new price is not stored and the baseline stays.
- Matas does not log in, does not store personal data, and does not read a membership price that is not in the public JSON-LD price it keeps.

Default memory is 512 MB. There is no proxy setting in the input.

### 💳 How much will it cost to scrape Matas?

Pay per event. The table copies the live `pricingInfos` for the events this code passes to Actor.charge. The amounts are the live tier prices, not a rounded marketing price.

| Event name (`Actor.charge`) | Event title | When the code charges it | Price (USD) |
|---|---|---|---|
| `product-checked` | Product Checked | One saved product page included a price. A first baseline and a later unchanged reading both use this event. | FREE 0.004 / BRONZE 0.003 / SILVER 0.0025 / GOLD 0.002 / PLATINUM 0.002 / DIAMOND 0.002 |
| `price-changed` | Price Changed | Charged in addition to the product check when the price or availability differs from the saved baseline. The first baseline is not this event. | FREE 0.002 / BRONZE 0.002 / SILVER 0.002 / GOLD 0.002 / PLATINUM 0.002 / DIAMOND 0.002 |

1,000 `product-checked` events at the FREE unit price of 0.004 USD are 4 USD. The lowest unit price on the live price list is 0.0005 USD for `apify-actor-start` on FREE, which is 0.5 USD for 1,000 events. These figures are copied from the live price list. They are not rounded.

`apify-actor-start` is on the live price list at 0.0005. This code does not call Actor.charge for that name. The platform can still bill Actor Start from the price list.

A page without a price, an HTTP error, a challenge page, a skip after HTTP 429, and a target the spending limit cannot pay for are not charged. `charged` is true only when Actor.charge returns a chargedCount that covers every event for that row. An ignored charge is stored as `charged` false and is not a spending limit. The row can still be kept.

### 📝 Input

| Field | Required | What the code does with it |
|---|---|---|
| Product URLs | Yes | Matas product URLs. The path must be one https://www.matas.dk product URL. Home, search, account, cart, and checkout URLs are rejected. The price is read from Product JSON-LD, including a ProductGroup variant when that is where the page puts the Product. When that block has no price, the public product detail on the same page is read. |
| Only changes | No | Off in the prefill, so a repeated sample still writes the current reading. On, after a baseline exists, writes a row only when the saved reading moved. A first read is always written. The schema default is on. |
| Watchlist name | No | Runs that share this name share one baseline. The prefill is `default`. The name must be 80 characters or fewer. |

```json
{
  "productUrls": [
    "https://www.matas.dk/vichy-mineral-89-booster-50-ml"
  ],
  "onlyChanges": false,
  "monitorName": "default"
}
```

### 📊 Output

One shortened record from the dataset schema example for the sample page. The field names are the names the code writes.

```json
{
  "recordType": "observation",
  "status": "baseline_saved",
  "name": "Vichy Minéral 89 Booster 50 ml",
  "sku": "769170",
  "price": 239.95,
  "currency": "DKK",
  "availability": "InStoreOnly",
  "productUrl": "https://www.matas.dk/vichy-mineral-89-booster-50-ml",
  "attribution": "Matas"
}
```

| Field | Meaning |
|---|---|
| `recordType` | `observation` for one saved reading. |
| `status` | `baseline_saved`, `unchanged`, `changed`, `no_data`, `api_error`, `unreachable`, `rate_limited`, or `not_fetched`. |
| `changeType` | `baseline`, `unchanged`, or `changed`. |
| `name` | Product name from the page. |
| `sku` | SKU from the page. |
| `gtin13` | GTIN-13 when the page prints one. Otherwise null. |
| `price` | Price kept from the page. |
| `currency` | Currency code from the page. |
| `availability` | Schema.org availability from the page, or null when the page does not print one. |
| `productUrl` | Product page after the query string is removed. |
| `attribution` | `Matas` when a price was kept. |
| `charged` | True only when Actor.charge covered the events for the row. |
| `chargeOutcome` | `succeeded`, `ignored`, `rejected`, or `not_charged`. |

### 🔌 Integrations and API

Run this Actor with the Apify API, a schedule, or the Apify MCP server. Apify can send the dataset to Make, Zapier, or a webhook. This Actor does not implement a custom integration of its own.

The input object uses keys from the input schema. The slug is `mmdincer/matas-product-price-monitor`.

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('mmdincer/matas-product-price-monitor').call({"productUrls": ["https://www.matas.dk/vichy-mineral-89-booster-50-ml"], "onlyChanges": false, "monitorName": "default"});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("mmdincer/matas-product-price-monitor").call(run_input={"productUrls": ["https://www.matas.dk/vichy-mineral-89-booster-50-ml"], "onlyChanges": false, "monitorName": "default"})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

### ❓ FAQ

#### How do I scrape Matas with a small first run?

Keep the prefilled URL, leave only changes off, and leave the watchlist name as `default`. That is one product page. Run it twice: the first row is a baseline, and the second is unchanged while the price and availability stay the same.

#### Does Matas search the shop?

No. Matas reads only the product URLs in the input. Home, search, account, cart, and checkout URLs are rejected before a request.

#### What does Matas skip without a charge?

`no_data`, HTTP errors, challenge pages, and targets skipped for the spending limit do not call Actor.charge for `product-checked` or `price-changed`. The first baseline is a product check, not a price change.

#### Can I keep two Matas lists apart?

Yes. The watchlist name is the baseline key. Use a new name to start over without deleting the old snapshot.

#### Is an owner run Store QA?

No. An owner run of the sample is not Store QA.

### ⚖️ Is it legal to scrape Matas?

Matas reads a public product page. It does not log in, and it does not store a person's name, a review, or an image. The terms page that was read is https://www.matas.dk/handelsbetingelserne. It is the online-shop contract. Automatisk on that page is the order-confirmation email sent after an order. The words scrape, crawl, spider, and robot do not appear. There is no written open licence for the price. Reviews on the product page can include a person's name, and this Actor does not store reviews or names. For User-agent: \* the robots file disallows /internal/, the payment handler paths, and /hkb/. The product slug is not in that list.

Not affiliated with Matas. Matas does not endorse this Actor.

This is not legal advice. You are responsible for the source's terms and, if you process personal data, for GDPR. Apify's overview: <https://blog.apify.com/is-web-scraping-legal/>.

### 🔗 Related actors

| Actor | What it does |
|---|---|
| [Lyko Price Monitor - Beauty product prices for Sweden](https://apify.com/mmdincer/lyko-product-price-monitor) | Public Lyko beauty price and availability. |
| [Toolstation Price Monitor - Trade prices for the UK](https://apify.com/mmdincer/toolstation-product-price-monitor) | Public Toolstation product price and availability. |
| [Clas Ohlson Price Monitor - Hardware prices for Sweden](https://apify.com/mmdincer/clas-ohlson-product-price-monitor) | Public Clas Ohlson product price and availability. |

# Changelog

This Actor's version history is a separate document: https://apify.com/mmdincer/matas-product-price-monitor/changelog.md

# Actor input Schema

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

https://www.matas.dk product pages. Search, account, cart, and checkout URLs are rejected.

## `onlyChanges` (type: `boolean`):

Leave this off for the sample so a repeated run still writes the current reading. Turn it on after a baseline exists when the dataset should list a target only if the saved reading moved. A first read is always written.

## `monitorName` (type: `string`):

Runs that share this name share one baseline.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.matas.dk/vichy-mineral-89-booster-50-ml"
  ],
  "onlyChanges": false,
  "monitorName": "default"
}
```

# Actor output Schema

## `prices` (type: `string`):

Latest public price for each saved product.

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

Targets requested, baselines, changes, and how many events Actor.charge() billed.

# 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 = {
    "productUrls": [
        "https://www.matas.dk/vichy-mineral-89-booster-50-ml"
    ],
    "onlyChanges": false,
    "monitorName": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mmdincer/matas-product-price-monitor").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 = {
    "productUrls": ["https://www.matas.dk/vichy-mineral-89-booster-50-ml"],
    "onlyChanges": False,
    "monitorName": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("mmdincer/matas-product-price-monitor").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 '{
  "productUrls": [
    "https://www.matas.dk/vichy-mineral-89-booster-50-ml"
  ],
  "onlyChanges": false,
  "monitorName": "default"
}' |
apify call mmdincer/matas-product-price-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mmdincer/matas-product-price-monitor"
        }
    }
}
```

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/splolJn4y8grMUTpL/builds/UcP4a4UicuU8w2bdO/openapi.json
