# Prisjakt Price Comparison Scraper (`automation-lab/prisjakt-price-comparison-scraper`) Actor

Scrape Prisjakt for Nordic price intelligence: SEK featured offers, store counts, stock status, ratings, and product data for Swedish ecommerce monitoring.

- **URL**: https://apify.com/automation-lab/prisjakt-price-comparison-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Prisjakt Price Comparison Scraper

Scrape product prices, stores, stock status, ratings, images, and category data from public Prisjakt pages.

Use this actor for Swedish price intelligence, ecommerce monitoring, and product research workflows that need clean structured data from Prisjakt/PriceSpy pages.

### What does Prisjakt Price Comparison Scraper do?

Prisjakt Price Comparison Scraper turns public Prisjakt pages into a structured dataset.

It can collect product cards from Prisjakt search-style pages such as `https://www.prisjakt.nu/s/iphone-15/`.

For every extracted product row, the actor saves the product name, current price, currency, store name, stock status, brand, category, image, rating, and product URL.

### Who is it for?

Retail analysts use it to monitor competitor prices in Sweden.

Marketplace teams use it to track which stores are visible on Prisjakt for important products.

Brand managers use it to watch product positioning, ratings, and category placement.

Ecommerce agencies use it to build recurring price-monitoring reports for Nordic clients.

Developers use it as a ready Apify endpoint for Prisjakt data pipelines.

### Why use this actor?

✅ It extracts data from the public page payload instead of relying on fragile browser clicks.

✅ It returns clean fields that are ready for spreadsheets, BI tools, databases, and alerts.

✅ It includes Prisjakt-specific IDs such as product ID and store ID when available.

✅ It works with Apify datasets, webhooks, API clients, integrations, and MCP tools.

### What Prisjakt data can you extract?

| Field | Description |
| --- | --- |
| `productName` | Product title from Prisjakt |
| `currentPrice` | Featured offer price |
| `currency` | Currency, usually SEK |
| `storeName` | Store for the featured offer |
| `stockStatus` | Stock status such as in stock |
| `brandName` | Product brand |
| `categoryName` | Prisjakt category |
| `storeCount` | Number of stores listed for the product |
| `rating` | Prisjakt product rating |
| `url` | Product page URL |
| `offerLink` | Prisjakt go-to-shop offer URL |
| `imageUrl` | Product image URL |
| `coreProperties` | Product property chips shown by Prisjakt |
| `scrapedAt` | Timestamp of extraction |

### How much does it cost to scrape Prisjakt prices?

The actor uses pay-per-event pricing.

A run has a fixed `$0.005` start event and then charges per saved result.

The platform BRONZE price is `$0.0001` per Prisjakt product/featured-offer row, with standard Apify tier discounts for higher plans.

Use a low `maxItems` value for your first run if you only want to test the output format.

### Input

The main input is `startUrls`.

Add one or more public Prisjakt URLs.

Recommended URL pattern:

```json
{
  "startUrls": [
    { "url": "https://www.prisjakt.nu/s/iphone-15/" }
  ],
  "maxItems": 20
}
````

### Supported URL types

Search-style pages like `/s/iphone-15/` are the best starting point.

These pages usually contain multiple product cards in the initial HTML response.

Product pages can be used as a fallback for product-level metadata.

Generic query URLs may be more heavily protected, so user-supplied public listing URLs are recommended.

### Output example

```json
{
  "url": "https://www.prisjakt.nu/produkt.php?p=12105524",
  "productId": "12105524",
  "productName": "Apple iPhone 15 5G 6GB RAM 128GB",
  "brandName": "Apple",
  "categoryName": "Mobiltelefoner",
  "currentPrice": 6990,
  "currency": "SEK",
  "storeName": "CDON",
  "storeCount": 31,
  "stockStatus": "in_stock",
  "imageUrl": "https://pricespy-75b8.kxcdn.com/product/standard/280/12105524.jpg",
  "scrapedAt": "2026-05-20T00:00:00.000Z"
}
```

### How to scrape Prisjakt prices

1. Open the actor on Apify.
2. Paste one or more Prisjakt search/listing URLs into `startUrls`.
3. Set `maxItems` to the number of product rows you need.
4. Run the actor.
5. Download the dataset as JSON, CSV, Excel, XML, or HTML.
6. Schedule the actor if you need recurring price monitoring.

### Tips for best results

Use specific Prisjakt listing URLs rather than broad generic search URLs.

Start with 10 to 20 items to confirm that the page has the products you need.

Use several category or query pages when you need broader market coverage.

Store the `productId` and `storeId` fields if you plan to compare results over time.

Use `scrapedAt` as the timestamp in your price history table.

### Common use cases

📈 Daily price monitoring for a product portfolio.

🛒 Competitor store visibility checks.

📦 Stock status monitoring for high-demand products.

🔎 Product discovery in a Swedish ecommerce category.

📊 BI dashboards for price and assortment trends.

### Integrations

Send the dataset to Google Sheets for manual review.

Load the dataset into BigQuery, Snowflake, or Postgres for historical analysis.

Trigger Apify webhooks when a scheduled run finishes.

Use Make, Zapier, or n8n to send alerts when a monitored product changes price.

Connect the actor to a custom backend with the Apify API.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/prisjakt-price-comparison-scraper').call({
  startUrls: [{ url: 'https://www.prisjakt.nu/s/iphone-15/' }],
  maxItems: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/prisjakt-price-comparison-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.prisjakt.nu/s/iphone-15/'}],
    'maxItems': 20,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~prisjakt-price-comparison-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.prisjakt.nu/s/iphone-15/"}],"maxItems":20}'
```

### MCP integration

Use this actor from Claude Desktop, Claude Code, or any MCP-compatible client through Apify MCP.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/prisjakt-price-comparison-scraper
```

Claude Code setup:

```bash
claude mcp add apify-prisjakt "https://mcp.apify.com/?tools=automation-lab/prisjakt-price-comparison-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-prisjakt": {
      "url": "https://mcp.apify.com/?tools=automation-lab/prisjakt-price-comparison-scraper"
    }
  }
}
```

Example prompt:

```text
Scrape the first 20 products from https://www.prisjakt.nu/s/iphone-15/ and summarize the cheapest visible stores.
```

Another prompt:

```text
Run the Prisjakt price scraper for this URL and return a CSV-ready table with productName, currentPrice, storeName, and stockStatus.
```

### Scheduling

You can schedule the actor daily, weekly, or hourly on Apify.

Recurring schedules are useful for monitoring price movements over time.

Keep `maxItems` aligned with the number of products you need to track.

### Data quality notes

The actor extracts data from public Prisjakt page payloads.

Some pages may expose a featured offer rather than every offer on a product page.

If a field is not present in the source payload, it is omitted from that dataset row.

Prices are numeric values and currency is returned separately.

### Troubleshooting

If a run returns fewer items than expected, check that the input URL displays product cards in a normal browser.

If a generic search URL is blocked, use a public `/s/.../` style Prisjakt URL instead.

If a product page returns only one row, use a listing page when you need multiple products.

### Legality

This actor is intended for scraping publicly available information from Prisjakt pages.

You are responsible for using the data in accordance with applicable laws, Prisjakt terms, and your own compliance requirements.

Avoid collecting personal data and avoid overloading the target website.

### Related scrapers

You may also find these Apify actors useful:

- https://apify.com/automation-lab/amazon-product-scraper
- https://apify.com/automation-lab/e-commerce-scraping-tool
- https://apify.com/automation-lab/google-shopping-scraper
- https://apify.com/automation-lab/price-monitoring-scraper

### FAQ

#### Can I scrape multiple Prisjakt pages in one run?

Yes. Add multiple objects to `startUrls` and set `maxItems` high enough for the combined output.

#### Does it use a browser?

No. The MVP is HTTP-first because product data is present in the initial HTML payload for supported pages.

#### Can it scrape every store offer on a product?

The current output focuses on product cards and their featured offer. Product-page offer expansion can be added later if needed.

#### What country does it target?

The actor targets Swedish Prisjakt pages at `prisjakt.nu` and returns prices in SEK.

#### Can I monitor price changes?

Yes. Schedule recurring runs and compare `currentPrice` by `productId` and `scrapedAt` in your own database or spreadsheet.

### Changelog

Initial version extracts Prisjakt listing product cards with product, price, store, stock, rating, image, category, and timestamp fields.

# Actor input Schema

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

Prisjakt search, category, or product URLs to scrape. Search/listing pages like /s/iphone-15/ usually contain multiple product cards.

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

Maximum number of product or featured-offer records to save across all start URLs.

## `maxRequestRetries` (type: `integer`):

How many times to retry a failed Prisjakt HTTP request before skipping it.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.prisjakt.nu/s/iphone-15/"
    }
  ],
  "maxItems": 20,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (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.prisjakt.nu/s/iphone-15/"
        }
    ],
    "maxItems": 20,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/prisjakt-price-comparison-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.prisjakt.nu/s/iphone-15/" }],
    "maxItems": 20,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/prisjakt-price-comparison-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.prisjakt.nu/s/iphone-15/"
    }
  ],
  "maxItems": 20,
  "maxRequestRetries": 3
}' |
apify call automation-lab/prisjakt-price-comparison-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Prisjakt Price Comparison Scraper",
        "description": "Scrape Prisjakt for Nordic price intelligence: SEK featured offers, store counts, stock status, ratings, and product data for Swedish ecommerce monitoring.",
        "version": "0.1",
        "x-build-id": "gH5AerwNUdLI83c2g"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~prisjakt-price-comparison-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-prisjakt-price-comparison-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/automation-lab~prisjakt-price-comparison-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-prisjakt-price-comparison-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/automation-lab~prisjakt-price-comparison-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-prisjakt-price-comparison-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": "Prisjakt URLs",
                        "type": "array",
                        "description": "Prisjakt search, category, or product URLs to scrape. Search/listing pages like /s/iphone-15/ usually contain multiple product cards.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum products/offers",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of product or featured-offer records to save across all start URLs.",
                        "default": 50
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry a failed Prisjakt HTTP request before skipping it.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```