# DrMax Scraper - Pharmacy Products CZ SK PL RO (`studio-amba/drmax-scraper`) Actor

Scrape pharmacy products, prices, and availability from DrMax.cz, DrMax.sk, DrMax.pl, and DrMax.ro. Supports search queries and category URLs across 4 Central European countries. No login needed.

- **URL**: https://apify.com/studio-amba/drmax-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.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

## DrMax Scraper

Scrape pharmacy products, prices, and availability from **DrMax** — Central Europe's largest pharmacy chain with 3,000+ locations across Czech Republic, Slovakia, Poland, and Romania.

Extract medicines, supplements, cosmetics, dosage information, pack sizes, and pricing from all four DrMax e-commerce domains. No login or account needed.

### How to scrape DrMax data

1. Go to the [DrMax Scraper](https://apify.com/studio-amba/drmax-scraper) page on Apify Store.
2. Click **Try for free**.
3. Enter a search query (e.g., "ibuprofen", "vitamín C") or paste product/category URLs.
4. Select the country you want to scrape (CZ, SK, PL, RO).
5. Click **Start** and wait for the run to finish.
6. Download your data in JSON, CSV, Excel, or connect via API.

### What data can you extract from DrMax?

This scraper extracts the following fields from DrMax product pages:

| Field | Description |
|-------|-------------|
| `productName` | Full product name including dosage and form |
| `brand` | Brand or manufacturer name |
| `price` | Current selling price |
| `currency` | Currency code (CZK, EUR, PLN, RON) |
| `originalPrice` | Original price before discount |
| `discount` | Discount percentage or label |
| `category` | Product category from breadcrumbs |
| `inStock` | Whether the product is available |
| `dosageForm` | Form: tablets, capsules, syrup, gel, etc. |
| `packSize` | Package size (e.g., 20 tablets, 100 ml) |
| `imageUrl` | Main product image URL |
| `url` | Full product page URL |
| `productDescription` | Product description text |
| `country` | Country code (cz, sk, pl, ro) |
| `scrapedAt` | ISO 8601 timestamp |

### Supported countries

DrMax operates online pharmacies in four Central European countries:

| Country | Domain | Currency |
|---------|--------|----------|
| Czech Republic | drmax.cz | CZK |
| Slovakia | drmax.sk | EUR |
| Poland | drmax.pl | PLN |
| Romania | drmax.ro | RON |

All four domains share a similar page structure, so the scraper works consistently across all of them. Select the country in the input to target a specific domain, or provide direct URLs from any domain.

### Input options

#### Search mode

Enter a search query and select a country. The scraper will search DrMax and extract products from the results:

```json
{
    "searchQuery": "ibuprofen",
    "country": "cz",
    "maxResults": 50
}
````

#### URL mode

Provide specific product or category URLs. You can mix URLs from different countries:

```json
{
    "categoryUrls": [
        { "url": "https://www.drmax.cz/vitaminy-a-mineraly" },
        { "url": "https://www.drmax.sk/aspirin" }
    ],
    "maxResults": 100
}
```

#### Default behavior

If no search query or URLs are provided, the scraper defaults to searching "ibuprofen" on drmax.cz. This ensures the actor always returns data.

### Example output

```json
{
    "productName": "Dr. Max Ibuprofen 400 mg 100 potahovaných tablet",
    "brand": "Dr. Max",
    "price": 129,
    "currency": "CZK",
    "originalPrice": 159,
    "discount": "-19%",
    "category": "Bolest a zánět",
    "inStock": true,
    "dosageForm": "tablet",
    "packSize": "100 tablet",
    "imageUrl": "https://www.drmax.cz/media/product-image.jpg",
    "url": "https://www.drmax.cz/ibuprofen-dr-max-400-mg-potahovane-tablety-100-tablet",
    "productDescription": "Ibuprofen Dr. Max 400 mg je lék určený k úlevě od bolesti...",
    "country": "cz",
    "scrapedAt": "2026-06-09T12:00:00.000Z"
}
```

### How much does it cost to scrape DrMax?

The DrMax Scraper uses Playwright for browser-based extraction. Typical costs on the Apify platform:

| Results | Estimated cost | Time |
|---------|---------------|------|
| 20 products | ~$0.05 | ~2 min |
| 100 products | ~$0.15 | ~5 min |
| 500 products | ~$0.50 | ~15 min |

Costs depend on proxy usage and the number of pages visited. Using residential proxies is recommended for reliable results.

### Tips for best results

- **Use native language**: Search in Czech on drmax.cz, Polish on drmax.pl, etc. For example, use "vitamín C" instead of "vitamin C" for better results on Czech and Slovak domains.
- **Residential proxies recommended**: DrMax uses Cloudflare protection. Residential proxies provide the most reliable access.
- **Start with a small test**: Use `maxResults: 20` first to verify the scraper works with your proxy setup.
- **Category URLs for bulk extraction**: For large-scale scraping, use category URLs instead of search queries. Categories return more products.

### Use cases

- **Price comparison**: Compare pharmacy product prices across 4 Central European countries.
- **Market research**: Track medicine and supplement pricing and availability in the Czech, Slovak, Polish, and Romanian markets.
- **Inventory monitoring**: Monitor stock availability of specific products across DrMax domains.
- **Competitive analysis**: Compare DrMax pricing with other pharmacy chains in the region.
- **Product catalog extraction**: Build a database of pharmacy products with dosage forms, pack sizes, and pricing.

### Integrations

Connect DrMax Scraper output to your tools:

- **Google Sheets** — Export product data to spreadsheets
- **Slack / Email** — Get notifications when prices change
- **Webhooks** — Trigger actions when new data is available
- **API** — Access results programmatically via Apify API
- **Zapier / Make** — Connect to 5,000+ apps

### FAQ

**Is a DrMax account required?**
No. This scraper extracts publicly available product data without any login or authentication.

**Can I scrape prescription medicines?**
The scraper extracts publicly listed product information. Prescription medicines may appear in search results but typically don't show online pricing.

**How often should I run the scraper?**
For price monitoring, daily or weekly runs are recommended. DrMax updates prices and stock levels regularly.

**Why am I getting zero results?**
DrMax uses Cloudflare protection. Make sure you're using residential proxies in the proxy configuration. If you still get zero results, try reducing concurrency or increasing timeouts.

# Actor input Schema

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

Search for products by name or keyword. Use the native language for best results (e.g., 'ibuprofen', 'vitamín C', 'witamina D').

## `categoryUrls` (type: `array`):

DrMax category or product URLs to scrape. Supports all DrMax domains (drmax.cz, drmax.sk, drmax.pl, drmax.ro). Example: https://www.drmax.cz/vitaminy-a-mineraly

## `country` (type: `string`):

Which DrMax domain to use for search queries. Not needed when providing direct URLs.

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

Maximum number of products to return.

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

Proxy settings. DrMax uses Cloudflare protection — residential proxies recommended.

## Actor input object example

```json
{
  "searchQuery": "ibuprofen",
  "country": "cz",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "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": "ibuprofen",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DrMax Scraper - Pharmacy Products CZ SK PL RO",
        "description": "Scrape pharmacy products, prices, and availability from DrMax.cz, DrMax.sk, DrMax.pl, and DrMax.ro. Supports search queries and category URLs across 4 Central European countries. No login needed.",
        "version": "0.1",
        "x-build-id": "ookieXhYKvBYokQiE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~drmax-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-drmax-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~drmax-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-drmax-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~drmax-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-drmax-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. Use the native language for best results (e.g., 'ibuprofen', 'vitamín C', 'witamina D')."
                    },
                    "categoryUrls": {
                        "title": "Category or Product URLs",
                        "type": "array",
                        "description": "DrMax category or product URLs to scrape. Supports all DrMax domains (drmax.cz, drmax.sk, drmax.pl, drmax.ro). Example: https://www.drmax.cz/vitaminy-a-mineraly",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "cz",
                            "sk",
                            "pl",
                            "ro"
                        ],
                        "type": "string",
                        "description": "Which DrMax domain to use for search queries. Not needed when providing direct URLs.",
                        "default": "cz"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. DrMax uses Cloudflare protection — residential proxies recommended."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
