# Alko Scraper — Finnish Alcohol Catalog & Prices (`studio-amba/alko-scraper`) Actor

Scrape Alko.fi, Finland's state alcohol retail monopoly. Search 11,000+ wines, beers, and spirits by keyword or category and extract names, prices in EUR, alcohol percentage, volume, package type, stock, and tasting notes as clean JSON. No login or cookies required.

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

## Alko Scraper — Finnish Alcohol Catalog & Prices

Scrape product data from [Alko](https://www.alko.fi), Finland's state-owned alcohol retail monopoly. Alko is the only retailer allowed to sell beverages above 8% ABV in Finland, so its catalog is the single authoritative source for alcohol prices and availability in the country — roughly 11,000 wines, beers, spirits, and ciders.

Search by keyword or category, and get clean JSON with names, prices in EUR, alcohol percentage, volume, package type, stock levels, and Alko's own tasting notes. No login, no cookies, no browser required.

### What you get

- **Full catalog access** — around 11,000 products across every category Alko sells
- **Prices in EUR** — the official state retail price
- **Product details** — ABV, volume, country of origin, package type, product group
- **Stock data** — online availability and webshop stock levels per product
- **Tasting notes** — Alko's published Finnish tasting descriptions, e.g. "savuinen, turpeinen, merellinen"
- **Direct product URLs** — deep links to each product page on alko.fi

### Use cases

- **Price monitoring** — track Finnish state alcohol prices over time, including tax-driven revisions
- **Assortment analysis** — which producers, countries, and styles are listed in the Finnish monopoly
- **Import and export research** — check whether your product (or a competitor's) is in the Finnish assortment and at what price
- **Availability tracking** — webshop stock levels for sought-after releases
- **Wine, beer, and whisky databases** — enrich your own product data with official Finnish pricing and tasting notes

### Input

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Search keyword in Finnish or English, e.g. `viski`, `punaviini`, `IPA`, or a producer name. Defaults to `viski` when empty. |
| `category` | string | Optional category keyword (Finnish), e.g. `olut`, `punaviini`, `valkoviini`, `kuohuviini`, `gini`. Combined with the search query as full-text terms. |
| `maxResults` | integer | Maximum number of products to return. Default `100`. |
| `proxyConfiguration` | object | Apify proxy settings. Datacenter proxies work; Finnish residential (`RESIDENTIAL`, country `FI`) is the fallback if you ever see 403s. |

Example input:

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

Browse a category instead of searching:

```json
{
    "category": "olut",
    "maxResults": 1000,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

### Output

One dataset item per product:

```json
{
    "productName": "Two Stacks Triple Barrel Single Pot Still tölkki",
    "category": "viskit",
    "mainGroup": "väkevät",
    "price": 8.02,
    "currency": "EUR",
    "alcoholPercent": 43,
    "volumeMl": 100,
    "country": "Irlanti",
    "packageType": "tölkki",
    "inStock": true,
    "webshopStock": 45,
    "tastingNotes": "Vaaleankeltainen, lämmin, keskitäyteläinen, viljainen, mallaskeksinen, hennon sitruksinen, kevyen hunajainen, pähkinäinen",
    "productNumber": "200045",
    "url": "https://www.alko.fi/fi/tuotteet/200045",
    "imageUrl": "https://images.alko.fi/images/t_pdp/cdn/200045/two-stacks-triple-barrel-single-pot-still-tolkki.jpg",
    "scrapedAt": "2026-07-11T19:46:15.044Z"
}
```

### How to scrape Alko data

1. Open the actor and press **Try for free** (or run it via the Apify API).
2. Enter a `searchQuery` — Finnish terms like `viski`, `olut`, or `punaviini` give the most precise matches, but producer names and English style terms work too.
3. Set `maxResults`. To cover the full assortment, run broad category keywords (`olut`, `punaviini`, `valkoviini`, `viski`, `gini`, `likööri`) and combine the datasets, or schedule one run per category.
4. Run the actor. Results land in the dataset and can be exported as JSON, CSV, or Excel, or fetched through the [Apify API](https://docs.apify.com/api/v2).

To track prices or stock on a schedule, create a Schedule in the Apify Console and point it at this actor with your saved input.

### FAQ

#### Is scraping Alko legal?

The actor only collects publicly available product information (names, prices, attributes, tasting notes) that anyone can see on alko.fi. It does not collect personal data and does not log in. Always check that your use of the data complies with applicable law and the site's terms.

#### How current is the data?

Every run queries Alko's own product search API — the same backend the site's search box uses. Prices, availability, and stock levels are as fresh as the moment you run the actor.

#### What happened to Alko's downloadable price list?

Alko used to publish an xlsx price list ("Alkon hinnasto tekstitiedostona"). That file is gone since Alko rebuilt its website. This actor replaces it with live structured data.

#### Does it need Finnish proxies?

Usually not. Alko's edge only filters obvious bot user agents, and this actor sends real browser headers, so the default `useApifyProxy: true` passes from datacenter IPs. If you see repeated 403s in the log, switch the proxy configuration to the `RESIDENTIAL` group with country `FI`.

#### Are tasting notes included for every product?

Almost all listed products carry Alko's tasting description in Finnish. The actor caps them at 500 characters per item to keep datasets compact.

### Related actors

Scraping the Nordics? These actors pair well with this one:

- [Systembolaget Scraper](https://apify.com/studio-amba/systembolaget-scraper) — Sweden's state alcohol monopoly: the same data for the Swedish market
- [Gigantti Scraper](https://apify.com/studio-amba/gigantti-fi-scraper) — Finland's largest electronics retailer
- [Elgiganten Scraper](https://apify.com/studio-amba/elgiganten-se-scraper) — Sweden's largest electronics retailer
- [Prisma Scraper](https://apify.com/studio-amba/prisma-scraper) — Finnish grocery and department store products
- [Barbora Scraper](https://apify.com/studio-amba/barbora-lt-scraper) — the Baltics' leading online grocery

### Support

Found an issue or missing a field you need? Open an issue on the actor's **Issues** tab in the Apify Console and it will be picked up quickly.

# Actor input Schema

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

Product search keyword in Finnish or English, e.g. 'viski', 'punaviini', 'IPA', or a producer name. Leave empty for the default 'viski' search.

## `category` (type: `string`):

Optional category keyword (Finnish), e.g. 'olut', 'punaviini', 'valkoviini', 'kuohuviini', 'gini'. It is combined with the search query as full-text search terms.

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

Maximum number of products to scrape. The full catalog is roughly 11,000 products.

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

Proxy settings. Alko's search API works from datacenter proxies with a browser User-Agent. If you see 403 blocks, switch to residential proxies with country Finland (FI).

## Actor input object example

```json
{
  "searchQuery": "viski",
  "maxResults": 20,
  "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": "viski",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Alko Scraper — Finnish Alcohol Catalog & Prices",
        "description": "Scrape Alko.fi, Finland's state alcohol retail monopoly. Search 11,000+ wines, beers, and spirits by keyword or category and extract names, prices in EUR, alcohol percentage, volume, package type, stock, and tasting notes as clean JSON. No login or cookies required.",
        "version": "0.1",
        "x-build-id": "kqFLwJwRnSrRWfCdZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~alko-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-alko-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~alko-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-alko-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~alko-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-alko-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": "Product search keyword in Finnish or English, e.g. 'viski', 'punaviini', 'IPA', or a producer name. Leave empty for the default 'viski' search."
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Optional category keyword (Finnish), e.g. 'olut', 'punaviini', 'valkoviini', 'kuohuviini', 'gini'. It is combined with the search query as full-text search terms."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 15000,
                        "type": "integer",
                        "description": "Maximum number of products to scrape. The full catalog is roughly 11,000 products.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Alko's search API works from datacenter proxies with a browser User-Agent. If you see 403 blocks, switch to residential proxies with country Finland (FI)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
