# Elgiganten.se Scraper — Swedish Electronics & Appliances (`studio-amba/elgiganten-se-scraper`) Actor

Scrape products, prices, specs, ratings, and availability from Elgiganten.se, Sweden's largest electronics retailer (Elkjop group). Supports keyword search, category browsing, and detailed product data. No cookies or login required.

- **URL**: https://apify.com/studio-amba/elgiganten-se-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 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.

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

## Elgiganten.se Scraper

Scrapes Sweden's largest electronics retailer, Elgiganten.se (part of the Elkjop/Elgiganten Nordic group). The scraper renders the live storefront and extracts structured product data from the search and category result pages, returning clean, normalised records.

This is the Swedish sibling of the Elgiganten.dk (Denmark) scraper. It runs on the same platform and extraction approach, tuned for the Swedish market: Swedish-krona (SEK) prices, Swedish stock and rating labels, and Swedish category paths.

### What it extracts

Elgiganten.se is a client-rendered storefront. The scraper loads each result page, dismisses the Swedish cookie banner, and reads product cards after hydration. For every product it returns the name, brand, current price, availability, rating, category, and image.

Swedish shops display both an incl-VAT consumer price and an excl-VAT price (`Exkl. moms`). The scraper always returns the marketed incl-VAT price, so figures match what a shopper sees. Where a product is on offer, it also captures the previous price (`Ord. pris`) and the saving.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | Conditional | e.g. `"mobiltelefon"`, `"kylskåp"`, `"samsung tv"` |
| `categoryUrl` | String | Conditional | e.g. `https://www.elgiganten.se/datorer-kontor/datorer/baerbara-datorer` |
| `maxResults` | Integer | No | Default: 100 |
| `proxyConfiguration` | Object | No | Proxy settings (Sweden residential recommended) |
| `sbrWsCdp` | String | No | Scraping Browser CDP endpoint for anti-bot bypass |

One of `searchQuery` or `categoryUrl` is required. When both are empty the scraper falls back to a default search so an empty run still returns data.

### Output

| Field | Type | Example |
|-------|------|---------|
| `name` | String | `"iPhone 15 128GB Black"` |
| `brand` | String | `"Apple"` |
| `price` | Number | `8990` |
| `currency` | String | `"SEK"` |
| `originalPrice` | Number | `9990` |
| `discount` | String | `"Spara 1000 kr"` |
| `inStock` | Boolean | `true` |
| `rating` | Number | `4.7` |
| `category` | String | `"mobil surfplatta smartwatch > mobiltelefon"` |
| `categories` | Array | `["mobil surfplatta smartwatch", "mobiltelefon"]` |
| `imageUrl` | String | Product image URL |
| `url` | String | Full product page URL |
| `scrapedAt` | String | ISO 8601 timestamp |

### Cost

Listing mode reads roughly 48 products per result page, so cost per product is low. Run with a small `maxResults` first to gauge the cost for your query, then scale up.

### Notes

- Prices are the incl-VAT consumer price in Swedish kronor (SEK)
- Ratings are only present for products that have been reviewed; unrated items omit the field
- Availability reflects the Swedish stock labels (`I lager online`, `Slutsåld`)
- Category is derived from the product URL path (Swedish category slugs)
- The site is anti-bot protected. A Scraping Browser endpoint (`sbrWsCdp` input or `SBR_WS_CDP` environment variable) is required for reliable runs
- No login or cookies required — the scraper works against publicly available pages

### Why use Elgiganten.se Scraper

- **Price monitoring** — Track prices, stock, and promotions across Elgiganten.se at scale
- **Competitive intelligence** — Compare your catalogue against Swedish electronics pricing and assortment
- **Market research** — Analyse category trends, new arrivals, and rating distributions in Sweden
- **Lead generation** — Build product datasets for affiliate sites, comparison tools, or feeds
- **No login or cookies required** — Authenticated access not needed; works out of the box

### How to use Elgiganten.se Scraper

1. Open the **Input** tab and provide a search query or a category URL
2. Adjust optional settings such as `maxResults` or proxy configuration
3. Click **Start** and wait for the run to complete
4. Download results from the **Output** tab in JSON, CSV, Excel, XML, or HTML
5. Schedule recurring runs from the **Schedule** tab if you need ongoing data

### How to scrape Elgiganten.se data

This Actor automates the process of extracting structured product data from Elgiganten.se.
You can run it directly from the Apify console, the Apify API, or any of the
official SDKs (JavaScript, Python). The scraper handles pagination, cookie
consent, and rendering so you can focus on the data, not the plumbing.

Typical workflows:

- **One-off export**: paste a category URL or keyword, set `maxResults`, and run
- **Scheduled monitoring**: set a daily cron in the Schedule tab to track prices over time
- **Programmatic integration**: trigger runs from your backend via the Apify API and
  pull the dataset when finished
- **Webhook automation**: receive a callback the moment a run completes and pipe
  the results into Zapier, Make, n8n, BigQuery, or Google Sheets

### Tips for best results

- **Start small** — run with `maxResults: 10` before launching large jobs
- **Use Swedish proxies** — a Sweden residential proxy returns local pricing and stock
- **Use native keywords** — Swedish terms like `kylskåp`, `bärbar dator`, `tv` match best
- **Schedule runs** — daily runs are usually enough for price monitoring
- **Inspect the dataset schema** — the Storage tab shows the full output structure

### FAQ and support

**Is it legal to scrape Elgiganten.se?** This Actor extracts publicly available data.
Always review the website's Terms of Service before scraping at scale, and
respect rate limits.

**Why am I getting fewer results than expected?** Some categories load more on
scroll or have hidden pagination. Increase `maxResults` and verify your query.

**Which currency are prices in?** Swedish kronor (SEK), and always the incl-VAT
consumer price shown to shoppers.

**The site blocks me — what should I do?** Provide a Scraping Browser endpoint via
the `sbrWsCdp` input or the `SBR_WS_CDP` environment variable, and enable Sweden
residential proxies. Datacenter IPs are blocked by many e-commerce sites.

### Related Scrapers

- [Elgiganten.dk Scraper](https://apify.com/studio-amba/elgiganten-dk-scraper) — the Danish market (Elgiganten.dk), same platform, prices in DKK
- Browse more **electronics** and e-commerce scrapers from Studio AMBA on the Apify Store for other Nordic and European retailers

For issues, feature requests, or bug reports, open a ticket in the Issues tab on
the Actor page or contact support@apify.com. We monitor every actor and ship
fixes quickly when sites change.

# Actor input Schema

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

Search for products by keyword (e.g., 'mobiltelefon', 'kylskåp', 'samsung tv'). Uses the Elgiganten.se search.
## `categoryUrl` (type: `string`):

An Elgiganten.se category page URL to scrape. Example: https://www.elgiganten.se/datorer-kontor/datorer/baerbara-datorer. Leave empty to use search query instead.
## `maxResults` (type: `integer`):

Maximum number of products to return.
## `sbrWsCdp` (type: `string`):

Bright Data Scraping Browser WebSocket CDP endpoint. Required to bypass the site's anti-bot checkpoint. Can also be set as SBR_WS_CDP environment variable.
## `proxyConfiguration` (type: `object`):

Select proxies to be used by this actor.

## Actor input object example

```json
{
  "searchQuery": "mobiltelefon",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "SE",
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
````

# 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 = {
    "searchQuery": "mobiltelefon",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "SE",
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/elgiganten-se-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 = {
    "searchQuery": "mobiltelefon",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyCountry": "SE",
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/elgiganten-se-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 '{
  "searchQuery": "mobiltelefon",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "SE",
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/elgiganten-se-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Elgiganten.se Scraper — Swedish Electronics & Appliances",
        "description": "Scrape products, prices, specs, ratings, and availability from Elgiganten.se, Sweden's largest electronics retailer (Elkjop group). Supports keyword search, category browsing, and detailed product data. No cookies or login required.",
        "version": "0.1",
        "x-build-id": "FhAdgNTOMXoWK02MW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~elgiganten-se-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-elgiganten-se-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~elgiganten-se-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-elgiganten-se-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~elgiganten-se-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-elgiganten-se-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for products by keyword (e.g., 'mobiltelefon', 'kylskåp', 'samsung tv'). Uses the Elgiganten.se search."
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "An Elgiganten.se category page URL to scrape. Example: https://www.elgiganten.se/datorer-kontor/datorer/baerbara-datorer. Leave empty to use search query instead."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "sbrWsCdp": {
                        "title": "Scraping Browser CDP URL",
                        "type": "string",
                        "description": "Bright Data Scraping Browser WebSocket CDP endpoint. Required to bypass the site's anti-bot checkpoint. Can also be set as SBR_WS_CDP environment variable."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by this actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
