# Apohem Scraper — Swedish Online Pharmacy Products & Prices (`studio-amba/apohem-scraper`) Actor

Scrape products, prices, and availability from Apohem.se — a Swedish online pharmacy. Supports search queries and category browsing.

- **URL**: https://apify.com/studio-amba/apohem-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 $1.20 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Apohem Scraper — Swedish Online Pharmacy: Products, Prices & Stock Data

Extract products, prices, brands, stock status, and images from [Apohem.se](https://www.apohem.se) — a Swedish online pharmacy selling non-prescription medicines, vitamins, skincare, and wellness products.

### What is Apohem Scraper?

Apohem is one of several online pharmacies competing for the Swedish digital health and wellness market, alongside larger players like Apotea and Apotek Hjärtat. It sells over-the-counter medicines, supplements, skincare, and personal care products through a standard search and category browsing structure built on EPiServer/Optimizely Commerce.

This actor extracts product data directly from Apohem's server-rendered listing pages (search results and category pages) — no browser automation needed. It anchors extraction on stable structural attributes (`data-test-id`, `data-product-id`, `itemProp`, `alt` text) rather than the site's CSS-modules hashed class names, so it keeps working across Apohem's frontend deploys. What people build with it:

- **Pharmacy pricing intelligence** — competing Swedish pharmacies track Apohem's prices to stay competitive on overlapping SKUs.
- **Health & beauty market research** — supplement and skincare brands monitor how their products are priced and stocked on Apohem.
- **Product catalogue enrichment** — comparison sites and health platforms pull structured product data (names, brands, EAN codes, images) to populate their own listings.
- **Availability monitoring** — track which products go out of stock or come back, and how often prices change.
- **Cross-pharmacy comparison** — combine with our other Nordic pharmacy scrapers to build a full Swedish/Danish pharmacy price index.

### What data does Apohem Scraper extract?

Each product record includes:

- **Product name** — full product title in Swedish
- **Brand** — manufacturer or brand name
- **Price** — current price in SEK (Swedish kronor)
- **Original price** — pre-discount reference price ("Ord.pris"), when the product is on sale
- **Currency** — always SEK
- **Product ID / SKU** — the site's numeric EAN/GTIN identifier
- **Stock status** — whether the product is currently in stock ("Finns i lager")
- **Image** — primary product image URL
- **Category** — top-level category slug derived from the product URL
- **Is medicine** — flagged `true` when Apohem shows a "Läkemedel" (medicine) badge on the product
- **Language** — `"sv"` (Swedish)
- **URL** — direct product link on apohem.se

### How to scrape Apohem data

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Search by keyword: `"vitamin"`, `"hudvard"` (skincare), `"solskydd"` (sunscreen) |
| `categoryUrl` | String | No | An Apohem category to browse instead of searching, e.g. `"hudvard"` or a full URL. Ignored if `searchQuery` is set. |
| `maxResults` | Integer | No | Maximum products to return (default: 50, max: 10,000) |
| `proxyConfiguration` | Object | No | Proxy settings — plain Apify Proxy works by default; switch to RESIDENTIAL/SE if you see failures |

**Tips:**

- Use **Swedish keywords** for best coverage: `"vitaminer"` (vitamins), `"hudvard"` (skincare), `"tandvard"` (dental care), `"smartstillande"` (painkillers).
- Avoid ultra-specific single-product queries (e.g. `"alvedon"`) — Apohem 302-redirects those straight to one product page instead of a search results list. Broader terms like `"vitamin"` or `"alvedon 500mg"` return proper result grids.
- For category-wide scraping, use a top-level category slug from apohem.se's navigation: `hudvard`, `vitaminer-kosttillskott`, `smink`, `traning`, `munvard`, `mage-tarm`, and others.
- No login or cookie acceptance is required to read product listings.

### Output

```json
{
    "name": "Holistic Mega B-komplex 90 vegetabiliska kapslar",
    "brand": "Holistic",
    "price": 120,
    "currency": "SEK",
    "url": "https://www.apohem.se/vitaminer-kosttillskott/vitaminer-mineraler/b-vitaminer/b-vitaminkomplex/holistic-mega-b-komplex-90-vegetabiliska-kapslar",
    "scrapedAt": "2026-07-25T10:22:34.432Z",
    "language": "sv",
    "originalPrice": 150,
    "productId": "7350012335816",
    "sku": "7350012335816",
    "inStock": true,
    "imageUrl": "https://www.apohem.se/cdn-cgi/image/width=1600,format=auto/globalassets/raderas-ej/produktbilder-radera-ej/7350012335816.jpg",
    "category": "vitaminer-kosttillskott"
}
````

Medicine-flagged products (e.g. searching `"alvedon 500mg"`) additionally carry `"isMedicine": true`:

```json
{
    "name": "Alvedon Tabletter 500 mg Paracetamol 20 st",
    "brand": "Alvedon",
    "price": 34,
    "currency": "SEK",
    "url": "https://www.apohem.se/vark-feber/huvudvark/alvedon-tabletter-500-mg-paracetamol-20-st",
    "inStock": true,
    "category": "vark-feber",
    "isMedicine": true
}
```

### How much does it cost?

Apohem's listing pages are plain server-rendered HTML — no browser rendering needed, so this actor is cheap to run.

| Volume | Estimated CUs | Estimated Cost |
|--------|--------------|----------------|
| 50 products | ~0.02 | ~$0.01 |
| 500 products | ~0.10 | ~$0.05 |
| 5,000 products | ~0.60 | ~$0.30 |

### Can I integrate?

Connect Swedish pharmacy data to your tools:

- **Google Sheets** — track prices on your product portfolio across the Swedish pharmacy market
- **Slack** — get alerts when specific health or beauty products go on sale on Apohem
- **Zapier / Make** — automate pricing updates for your competing pharmacy or health store
- **Webhooks** — stream product data to your own health product comparison platform
- **PostgreSQL / BigQuery** — build a historical Swedish pharmacy pricing database

### Can I use it as an API?

Yes. Build Swedish pharmacy intelligence into your stack:

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/apohem-scraper").call(run_input={
    "searchQuery": "vitamin",
    "maxResults": 50,
})

for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    stock = "I lager" if product.get("inStock") else "Slut"
    print(f"{product['name']} | {product['price']} SEK | {stock}")
```

**JavaScript:**

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

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

const run = await client.actor("studio-amba/apohem-scraper").call({
    searchQuery: "vitamin",
    maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const onSale = items.filter((p) => p.originalPrice && p.originalPrice > p.price);
console.log(`${onSale.length} products on sale:`);
onSale.forEach((p) => {
    const discount = Math.round((1 - p.price / p.originalPrice) * 100);
    console.log(`  ${p.name} | ${p.price} SEK (was ${p.originalPrice}, -${discount}%)`);
});
```

### FAQ

**Does Apohem sell prescription medications?**
This actor scrapes public product listing pages, which cover non-prescription medicines, supplements, skincare, and general health products.

**Is all data in Swedish?**
Yes. Product names and categories are in Swedish. The platform serves the Swedish market exclusively.

**Do I need residential proxies?**
No anti-bot blocking has been observed with a plain browser User-Agent (Cloudflare is present on the site but does not challenge standard requests). Standard Apify Proxy works by default; the `proxyConfiguration` input lets you switch to RESIDENTIAL/SE if that changes.

**How does pagination work?**
Apohem's listing endpoint accepts any page size directly for the first request, and continues in fixed 25-item increments for anything beyond that (matching the site's own "Visa fler" / load-more button). The actor handles this automatically — just set `maxResults`.

**Why did my narrow search return fewer products than expected?**
Very specific single-product searches (e.g. a single SKU name) redirect straight to that product's page instead of a results grid. Use a broader keyword to get a proper listing.

### Limitations

- Product card extraction from listing pages captures what's shown on the grid (name, brand, price, stock, image, category, medicine flag) — it does not fetch individual product detail pages for full descriptions or ingredient lists.
- Categories and product structures may change as Apohem updates their website; the actor is built to survive CSS class renames since it never depends on hashed class names.
- Data is scraped from the public website and may change without notice.

### Related Scrapers

Part of our Nordic pharmacy cluster:

- [Apotea Scraper](https://apify.com/studio-amba/apotea-scraper) — Sweden's largest online pharmacy
- [Apotek Hjärtat Scraper](https://apify.com/studio-amba/apotekhjartat-scraper) — Sweden's second-largest pharmacy chain
- [Matas Scraper](https://apify.com/studio-amba/matas-scraper) — Denmark's largest health & beauty retailer

### Your feedback

Need specific categories, richer product detail extraction, or price history tracking? Open an issue on GitHub or contact us through the Apify platform. We build what users need.

# Actor input Schema

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

Search for products by keyword (e.g., 'vitamin', 'hudvard', 'solskydd'). Uses Apohem's search page. Leave empty and set categoryUrl instead to browse a category.

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

An Apohem category page to scrape instead of searching. Example: https://www.apohem.se/hudvard or just 'hudvard'. Ignored if searchQuery is set.

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

Maximum number of products to return.

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

Proxy settings. Apohem.se has not shown anti-bot blocking even with plain Apify Proxy, but RESIDENTIAL Swedish exit IPs are used by default for reliability, matching our other Nordic pharmacy scrapers.

## Actor input object example

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

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apohem Scraper — Swedish Online Pharmacy Products & Prices",
        "description": "Scrape products, prices, and availability from Apohem.se — a Swedish online pharmacy. Supports search queries and category browsing.",
        "version": "0.1",
        "x-build-id": "AqZZVmJh9Mgr8abNK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~apohem-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-apohem-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~apohem-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-apohem-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~apohem-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-apohem-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., 'vitamin', 'hudvard', 'solskydd'). Uses Apohem's search page. Leave empty and set categoryUrl instead to browse a category."
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "An Apohem category page to scrape instead of searching. Example: https://www.apohem.se/hudvard or just 'hudvard'. Ignored if searchQuery is set."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Apohem.se has not shown anti-bot blocking even with plain Apify Proxy, but RESIDENTIAL Swedish exit IPs are used by default for reliability, matching our other Nordic pharmacy scrapers."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
