# Prisjakt Scraper — Swedish Price Comparison Data (`studio-amba/prisjakt-scraper`) Actor

Compare prices across Swedish retailers using Prisjakt.nu, Scandinavia's largest price comparison site. Get lowest prices, offer counts, and product details.

- **URL**: https://apify.com/studio-amba/prisjakt-scraper.md
- **Developed by:** [Jelle Desramaults](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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.

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 Scraper -- Nordic Price Comparison Data from Scandinavia's Largest Product Database

Extract product listings, lowest prices, number of store offers, ratings, and reviews from [Prisjakt.nu](https://www.prisjakt.nu) -- Sweden's and Scandinavia's biggest price comparison platform, aggregating prices from hundreds of online retailers across the Nordic region.

### What is Prisjakt Scraper?

Prisjakt (literally "price hunt" in Swedish) is the dominant price comparison engine in the Nordic countries. Founded in Sweden, it tracks prices from hundreds of online retailers for millions of products -- from electronics and home appliances to fashion and outdoor gear. Swedish consumers routinely check Prisjakt before making any significant online purchase, making it the single most important pricing reference in the Nordic e-commerce landscape.

This actor scrapes product data from search results and category pages, then visits individual product pages to extract detailed specifications. What people build with it:

- **Nordic pricing intelligence** -- e-commerce companies selling in Sweden, Norway, Denmark, and Finland monitor Prisjakt to understand competitive pricing across hundreds of retailers simultaneously.
- **Product availability tracking** -- brands and distributors check which of their products are listed on Prisjakt, at how many retailers, and at what price points.
- **Market entry research** -- companies planning Nordic market entry use Prisjakt data to benchmark pricing, identify popular categories, and understand the competitive landscape.
- **Consumer electronics monitoring** -- tech review sites and deal aggregators track product prices and offer counts to identify deals and price drops across Nordic retailers.
- **Academic research** -- economists studying online pricing, market competition, and price dispersion in Nordic markets use Prisjakt as a primary data source.

### What data does Prisjakt Scraper extract?

Each product listing includes:

- :shopping_cart: **Product name** -- full product title
- :label: **Brand** -- manufacturer brand
- :moneybag: **Lowest price** -- the cheapest available price in SEK (Swedish kronor)
- :currency_exchange: **Currency** -- SEK
- :department_store: **Number of offers** -- how many retailers list this product
- :star: **Rating** -- user rating score
- :speech_balloon: **Review count** -- number of user reviews
- :camera: **Image** -- product image URL
- :page_facing_up: **Description** -- product description from meta tags
- :file_folder: **Category** -- product category from breadcrumb navigation
- :id: **Product ID** -- Prisjakt's internal product identifier
- :link: **URL** -- direct link to the product page on prisjakt.nu

### How to scrape Prisjakt

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Search by keyword: `"laptop"`, `"hörlurar"` (headphones), `"dammsugare"` (vacuum cleaner) |
| `categoryUrl` | String | No | A Prisjakt category page URL to scrape |
| `maxResults` | Integer | No | Maximum products to return (default: 100, max: 10,000) |
| `proxyConfiguration` | Object | No | Proxy settings (Apify proxy recommended) |

**Tips:**

- Use **Swedish keywords** for best results: `"hörlurar"` (headphones), `"surfplatta"` (tablet), `"tvättmaskin"` (washing machine).
- English keywords also work for international product names (iPhone, PlayStation, etc.).
- The actor handles pagination automatically, following "Nasta" (Next) links through search results.
- For category-wide analysis, browse prisjakt.nu to find the category URL and paste it into `categoryUrl`.

### Output

```json
{
    "name": "Sony WH-1000XM5 Wireless",
    "brand": "Sony",
    "price": 2990,
    "currency": "SEK",
    "lowestPrice": 2990,
    "numOffers": 24,
    "rating": 4.7,
    "reviewCount": 892,
    "imageUrl": "https://www.prisjakt.nu/img/products/sony-wh1000xm5.jpg",
    "description": "Tradlosa over-ear horlurar med branschledande brusreducering, 30 timmars batteritid och multipoint Bluetooth-anslutning.",
    "category": "Horlurar",
    "productId": "5678901",
    "url": "https://www.prisjakt.nu/produkt/5678901",
    "scrapedAt": "2026-04-03T15:00:00.000Z"
}
````

### How much does it cost?

Prisjakt Scraper uses CheerioCrawler for efficient HTML parsing:

| Volume | Estimated CUs | Estimated Cost |
|--------|--------------|----------------|
| 100 products | ~0.03 | ~$0.015 |
| 500 products | ~0.12 | ~$0.06 |
| 1,000 products | ~0.25 | ~$0.13 |
| 5,000 products | ~1.10 | ~$0.55 |

The actor first collects product links from listing pages, then visits each detail page. Costs scale with the number of product pages visited.

### Can I integrate?

Stream Nordic pricing data into your systems:

- **Google Sheets** -- build a live Nordic price tracker for your product portfolio
- **Slack** -- get alerts when specific products drop below target prices in Sweden
- **Zapier / Make** -- automate competitive pricing workflows for Nordic markets
- **Webhooks** -- feed price data to your dynamic pricing engine
- **BigQuery / PostgreSQL** -- build a historical Nordic price database
- **Power BI / Tableau** -- visualise price trends across Swedish retailers

### Can I use it as an API?

Yes. Build Nordic pricing intelligence into your products:

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/prisjakt-scraper").call(run_input={
    "searchQuery": "laptop",
    "maxResults": 100,
})

for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    offers = product.get('numOffers', '?')
    print(f"{product['name']} - {product['price']} SEK ({offers} offers)")
```

**JavaScript:**

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

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/prisjakt-scraper").call({
    searchQuery: "laptop",
    maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.sort((a, b) => a.price - b.price);
console.log("Top 5 cheapest laptops on Prisjakt:");
items.slice(0, 5).forEach((p) => {
    console.log(`  ${p.name} - ${p.price} SEK (${p.numOffers || "?"} offers)`);
});
```

### FAQ

**Does Prisjakt cover all Nordic countries?**
Prisjakt.nu is the Swedish site. There are separate versions for Norway (prisjakt.no), Denmark, and Finland. This actor targets the Swedish version (prisjakt.nu).

**Are the prices always in SEK?**
Yes. Prisjakt.nu shows prices in Swedish kronor (SEK). Other country versions use their local currencies.

**Can I see which specific retailers offer a product?**
The actor extracts the number of offers (retailer count) but not individual retailer names and prices. For that level of detail, you would need to scrape individual product pages more deeply.

**How often are Prisjakt prices updated?**
Prisjakt crawls retailer websites continuously. Prices on the platform are typically updated multiple times per day. Your actor results reflect the prices at the time of scraping.

**Does it include price history?**
No. The actor captures the current lowest price. For historical price data, schedule the actor to run daily and build your own price trend database.

**Can I search in English?**
International product names (brands, model numbers) work fine. For generic categories, Swedish keywords yield better results.

**What makes Prisjakt different from Google Shopping?**
Prisjakt has deeper Nordic market penetration and more granular retailer data than Google Shopping in Sweden. Swedish consumers specifically search on Prisjakt before purchasing, and many smaller Nordic retailers are listed on Prisjakt but not on Google Shopping.

**Does Prisjakt include product specifications?**
Prisjakt product pages often contain detailed specifications (screen size, battery capacity, weight, etc.), but these vary by category. The actor currently extracts the main product metadata. Technical specifications as structured key-value pairs would require deeper per-product parsing.

**Can I track price drops over time?**
Prisjakt itself shows price history graphs on product pages, but this actor captures the current snapshot. Schedule the actor to run daily and compare results to build your own price trend database.

### Limitations

- Targets prisjakt.nu (Sweden) only. Norwegian and Danish versions have different URL structures.
- Product detail pages may not always contain all fields (rating, review count, number of offers) depending on the product and page structure.
- Prisjakt may use anti-bot protection on high-traffic pages. Apify proxy is recommended.
- Individual retailer offers (per-shop prices) are not extracted -- only the aggregated lowest price and offer count.
- Category pages can be very deep. Set `maxResults` to control the scope of your scrape.

### Related Nordic and price comparison scrapers

- [Ceneo Scraper](https://apify.com/studio-amba/ceneo-scraper) -- Poland's largest price comparison platform
- [Apotea Scraper](https://apify.com/studio-amba/apotea-scraper) -- Sweden's largest online pharmacy
- [Apotek Hjartat Scraper](https://apify.com/studio-amba/apotekhjartat-scraper) -- Swedish pharmacy chain products and prices
- [Norauto Scraper](https://apify.com/studio-amba/norauto-scraper) -- French automotive retail for European price comparison

### Your feedback

Need individual retailer prices, price history tracking, or support for other Nordic Prisjakt sites? Open an issue on GitHub or reach out through Apify. User feedback shapes our roadmap.

# Actor input Schema

## `categoryUrl` (type: `string`):

URL of a category page to scrape

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

Search term to find products

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

Maximum number of results

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

Apify proxy settings

## Actor input object example

```json
{
  "searchQuery": "laptop",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/prisjakt-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/prisjakt-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 '{}' |
apify call studio-amba/prisjakt-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Prisjakt Scraper — Swedish Price Comparison Data",
        "description": "Compare prices across Swedish retailers using Prisjakt.nu, Scandinavia's largest price comparison site. Get lowest prices, offer counts, and product details.",
        "version": "0.1",
        "x-build-id": "kEWeMihRmivlUBBuY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~prisjakt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-prisjakt-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/studio-amba~prisjakt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-prisjakt-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/studio-amba~prisjakt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-prisjakt-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",
                "properties": {
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "URL of a category page to scrape"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term to find products",
                        "default": "laptop"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of results",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy settings",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
