# ICA Scraper — Swedish Supermarket Prices (`studio-amba/ica-scraper`) Actor

Scrape products, prices, unit prices, brands, EANs and promotions from ICA.se — Sweden's largest supermarket. Search by keyword. No login or cookies required.

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

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## ICA Scraper — Swedish Supermarket Products & Prices

Scrape products, prices, unit prices, brands, SKUs, and promotions from
[ICA.se](https://www.ica.se), Sweden's largest supermarket chain. Search by
keyword and get clean, structured product data back as JSON, CSV, or Excel.

No login. No cookies. No browser automation on your side — you give the actor a
search term, it returns the matching products with prices for a real ICA store.

### What this actor does

ICA runs Sweden's biggest grocery network (ICA Maxi, ICA Kvantum, ICA
Supermarket, ICA Nära). Its online shop exposes a per-store product catalog with
live prices. This actor queries that catalog and returns one row per product.

For each product you get:

- **name** — the product name in Swedish
- **brand** — manufacturer / brand (e.g. Arla, ICA, Oatly)
- **sku** — ICA's retailer product id (stable per article)
- **price** — current shelf price for the selected store
- **currency** — always `SEK`
- **unit** — pack / size description (e.g. `1.5L`, `500 g`)
- **unitPrice** — comparison price (e.g. price per litre / kilo)
- **promotion** — the offer text when a product is on offer (e.g. `4 för 50 kr`)
- **promotionPrice** — single-unit discounted price when one applies
- **category** — product category
- **countryOfOrigin** — country of origin, when published
- **url** — direct link to the product page
- **imageUrl** — product image
- **inStock** — whether the product is currently available
- **scrapedAt** — ISO timestamp of the scrape

### How to scrape ICA data

1. Set **Search Query** to a Swedish keyword — for example `mjölk` (milk),
   `kaffe` (coffee), `bröd` (bread), `pasta`, or `ost` (cheese). Leave it empty
   and the actor falls back to a sensible default so you still get results.
2. Set **Max Results** to how many products you want back (default 20).
3. Leave **Store ID** on the default unless you need a specific store's prices.
   Prices and assortment differ between ICA stores. The default store is
   `1004599` (ICA Kvantum Kungsholmen, Stockholm).
4. Leave **Proxy Configuration** on the default Apify proxy. The product API
   has no geo lock, so you do not need Swedish IPs. Proxy is used only for IP
   rotation and rate-limit resilience.
5. Click **Start** and collect the dataset when the run finishes.

#### How the data is fetched

The online shop (`handlaprivatkund.ica.se`) is a single-page app keyed by a
store account id. The actor calls one public JSON endpoint:

````

GET /stores/{storeId}/api/webproductpagews/v6/product-pages/search
?q={term}\&tag=web\&maxPageSize=60
-> { productGroups: \[{ decoratedProducts: \[ { name, brand, price,
unitPrice, promotions, packSizeDescription, categoryPath, image } ] }],
metadata: { nextPageToken } }

````

The search returns fully decorated products (name, price, brand, image and
more) in one call — no second lookup needed. The actor paginates with
`nextPageToken` until it reaches your `maxResults`. Everything is store-scoped,
so the prices match what a shopper in that store would see online.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `searchQuery` | string | Swedish keyword to search for. Defaults to `mjölk`. |
| `maxResults` | integer | Max number of products to return (1–5000). |
| `storeId` | string | ICA online store account id. Default `1004599`. |
| `proxyConfiguration` | object | Proxy settings. Default Apify proxy is fine. |

#### Example input

```json
{
  "searchQuery": "kaffe",
  "maxResults": 50,
  "storeId": "1004599",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

### Output

Each dataset item looks like this:

```json
{
  "name": "Mellanmjölk 1,5% Ekologisk 1,5l KRAV ICA I love eco",
  "brand": "ICA I love eco",
  "sku": "2052770",
  "price": 23.5,
  "currency": "SEK",
  "unit": "1.5L",
  "unitPrice": "15.67/l",
  "promotion": null,
  "promotionPrice": null,
  "category": "Mellanmjölk",
  "countryOfOrigin": "Sverige",
  "url": "https://handlaprivatkund.ica.se/stores/1004599/products/2052770/details",
  "imageUrl": "https://handlaprivatkund.ica.se/images-v3/.../300x300.jpg",
  "inStock": true,
  "scrapedAt": "2026-06-24T18:00:00.000Z"
}
```

You can export the dataset as JSON, CSV, Excel, or XML, or pull it through the
Apify API.

### Common use cases

- **Price monitoring** — track ICA shelf prices for a basket of products over
  time and compare against other Swedish grocers.
- **Promotion tracking** — spot when products go on offer (`promotion`).
- **Assortment research** — see which brands and sizes ICA stocks for a category.
- **Market analysis** — feed structured Swedish grocery data into pricing models.

### Choosing a store

Prices and stock are per store. To use a different ICA store, find its account
id and pass it as `storeId`. You can list stores near any Swedish postcode with
ICA's public store endpoint, e.g.
`https://handla.ica.se/api/store/v1?zip=11122&customerType=B2C` — the `accountId`
field of each store is what this actor expects.

### Notes and limits

- Prices reflect the selected store and the moment of the scrape.
- ICA promotions are often multibuy offers (e.g. `4 för 50 kr`), so the
  `promotion` field carries the offer text. `promotionPrice` is filled only when
  a single-unit discounted price applies.
- The actor fails fast with a clear error if it gets zero products, so a
  successful run always means real data.

### FAQ

#### Do I need an ICA account or cookies?

No. The actor reads the public store catalog. No login, no cookies.

#### Do I need Swedish proxies?

No. The product API is reachable from any IP. The default Apify proxy is used
for IP rotation only. Note: do not country-lock a datacenter proxy to Sweden —
Apify has no Swedish datacenter pool. If you want a Swedish exit, pick
RESIDENTIAL and choose Sweden in the proxy editor.

#### Can I scrape a whole category?

Yes — search for a broad term and raise `maxResults`. The actor paginates
through the search results until it reaches your limit.

# Actor input Schema

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

Search for products by name or keyword in Swedish (e.g., 'mjölk', 'kaffe', 'bröd', 'pasta', 'ost'). Leave empty to scrape a sample of products from the catalog.

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

Maximum number of products to return.

## `storeId` (type: `string`):

ICA online store account id used to resolve regional assortment and prices. Prices and stock vary by store. The default (1004599 — ICA Kvantum Kungsholmen, Stockholm) works for most use cases. Leave as-is unless you need another store's prices.

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

Proxy settings for IP rotation and rate-limit resilience. The default Apify proxy works fine — the ICA product API has no geo lock. Do not country-lock datacenter proxies to 'SE' (Apify has no Swedish datacenter pool); if you need a Swedish IP, switch to RESIDENTIAL and pick Sweden.

## Actor input object example

```json
{
  "searchQuery": "mjölk",
  "maxResults": 20,
  "storeId": "1004599",
  "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 = {
    "searchQuery": "mjölk",
    "maxResults": 20,
    "storeId": "1004599",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/ica-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": "mjölk",
    "maxResults": 20,
    "storeId": "1004599",
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ICA Scraper — Swedish Supermarket Prices",
        "description": "Scrape products, prices, unit prices, brands, EANs and promotions from ICA.se — Sweden's largest supermarket. Search by keyword. No login or cookies required.",
        "version": "0.1",
        "x-build-id": "zJiPj8Sf8L8RsDL0r"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~ica-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-ica-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~ica-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-ica-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~ica-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-ica-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 name or keyword in Swedish (e.g., 'mjölk', 'kaffe', 'bröd', 'pasta', 'ost'). Leave empty to scrape a sample of products from the catalog."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 50
                    },
                    "storeId": {
                        "title": "Store ID (price region)",
                        "type": "string",
                        "description": "ICA online store account id used to resolve regional assortment and prices. Prices and stock vary by store. The default (1004599 — ICA Kvantum Kungsholmen, Stockholm) works for most use cases. Leave as-is unless you need another store's prices.",
                        "default": "1004599"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for IP rotation and rate-limit resilience. The default Apify proxy works fine — the ICA product API has no geo lock. Do not country-lock datacenter proxies to 'SE' (Apify has no Swedish datacenter pool); if you need a Swedish IP, switch to RESIDENTIAL and pick Sweden."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
