# REWE Scraper — German Supermarket Products & Prices (`studio-amba/rewe-scraper`) Actor

Scrape products, brands, categories, images and prices from shop.rewe.de, REWE's German online supermarket. Search by keyword, paginate, get clean JSON. No login or cookies.

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

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## REWE Scraper — German Supermarket Products & Prices

Scrape product data from [shop.rewe.de](https://shop.rewe.de), the online supermarket of REWE — one of Germany's largest grocery chains. Search by keyword and get clean, structured JSON with product names, brands, categories, article numbers, images, unit sizes and prices.

No login. No cookies. No browser automation. The actor talks to REWE's own product API directly, so it is fast and reliable.

### What this actor does

Give it a German search term (for example `milch`, `kaffee`, `schokolade`, `bio`, `nudeln`) and it returns every matching product from the REWE online shop, paginated up to your `maxResults` limit. Each product comes back as a flat JSON record ready to load into a spreadsheet, database or price-monitoring pipeline.

### How to scrape REWE data

1. Open the actor and enter a **Search Query** — a German keyword such as `milch`, `kaffee` or `schokolade`.
2. Set **Max Results** to how many products you want (default 50).
3. (Optional) Enter a **Market ID** to pull market-specific prices — see the pricing note below.
4. Click **Start**.
5. When the run finishes, download the dataset as JSON, CSV or Excel from the **Storage** tab.

That is the whole flow. The actor handles pagination automatically and stops once it has collected `maxResults` products or run out of matches.

#### Example input

```json
{
  "searchQuery": "kaffee",
  "maxResults": 40,
  "proxyConfiguration": { "useApifyProxy": true }
}
````

#### Example with prices (market supplied)

```json
{
  "searchQuery": "milch",
  "maxResults": 100,
  "marktId": "<your-valid-rewe-market-id>",
  "zip": "50667",
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### Output fields

Each item in the dataset has these fields:

| Field | Type | Description |
|---|---|---|
| `name` | string | Full product name, e.g. `Hochland Kaffee Holanka Crema 1kg` |
| `brand` | string | Brand / manufacturer, e.g. `Hochland Kaffee` |
| `sku` | string | REWE article number (the `nan`), e.g. `1438079` |
| `ean` | string | EAN barcode when available (empty for search results) |
| `price` | number | null | Current retail price in EUR (requires a valid Market ID) |
| `currency` | string | Always `EUR` |
| `unit` | string | Unit size from the price label, e.g. `1 l` |
| `unitPrice` | string | Base price (Grundpreis), e.g. `1 l = 0,99 €` |
| `promotionPrice` | number | null | Discounted price when on offer |
| `category` | string | null | Full category path, e.g. `Kaffee, Tee & Kakao/Kaffee/Bohnenkaffee ganze Bohnen` |
| `tags` | array | Product flags such as `Bio`, `Gekühlt`, `Regional` |
| `url` | string | Link to the product detail page |
| `imageUrl` | string | null | Product image URL (img.rewe-static.de) |
| `inStock` | boolean | Whether the product is currently listed |
| `scrapedAt` | string | ISO timestamp of when the record was scraped |

#### Example output item

```json
{
  "name": "Hemme Milch Frische Vollmilch 3,7% 1l",
  "brand": "Hemme Milch",
  "sku": "1042422",
  "currency": "EUR",
  "category": "Käse, Eier & Molkerei/Milch/Frischmilch",
  "tags": ["Gekühlt", "Regional"],
  "url": "https://shop.rewe.de/p/hemme-milch-frische-vollmilch-3-7-1l/1042422",
  "imageUrl": "https://img.rewe-static.de/1042422/8646730_digital-image.png",
  "inStock": true,
  "scrapedAt": "2026-06-24T10:00:00.000Z"
}
```

### A note on prices

Prices on shop.rewe.de are **market-specific** — REWE shows different prices and availability depending on which delivery or pickup market you are assigned to. The product search API returns full catalog metadata (name, brand, category, image, article number, URL) for every product without a market, but the price fields only populate when a **valid REWE Market ID** is supplied in the `marktId` input.

If you leave `marktId` empty, the actor returns the complete product catalog for your search term with all metadata, and the `price` / `unitPrice` / `promotionPrice` fields stay empty. This is ideal for catalog research, assortment analysis, brand tracking and matching products across retailers.

To pull live prices, supply a `marktId` that belongs to a real REWE delivery or pickup market. The `zip` field is a convenience label so you can record which postal code the prices belong to.

### Common search terms

REWE is a German shop, so use German keywords:

- `milch` — milk
- `kaffee` — coffee
- `schokolade` — chocolate
- `nudeln` — pasta
- `bio` — organic products
- `käse` — cheese
- `bier` — beer
- `wasser` — water
- `brot` — bread
- `joghurt` — yoghurt

### How it works

The actor calls REWE's public product search endpoint (`shop.rewe.de/api/products`) over the Apify Proxy, follows the redirect to the shop API, parses the JSON response and normalises each product into the flat schema above. It paginates through result pages until it reaches your `maxResults` limit. No headless browser is used, which keeps runs fast and cheap.

### Proxy

The default Apify Proxy works fine — the REWE products API is not geo-locked. The Apify datacenter pool has no Germany-specific group, so do not set the proxy country to `DE` on the datacenter group (it returns 407). If you specifically need a German exit IP, switch the proxy group to `RESIDENTIAL` with country `DE`.

### Use cases

- **Grocery price monitoring** — track REWE prices over time for selected products.
- **Assortment / catalog research** — see which products and brands REWE lists in a category.
- **Competitive analysis** — compare REWE against EDEKA, Kaufland and other German grocers.
- **Product matching** — build a cross-retailer product map using names, brands and article numbers.
- **Market research** — analyse brand presence, organic (`Bio`) share, regional products and more.

### Notes & limitations

- The search payload does not include EAN barcodes, so `ean` is usually empty. Use `sku` (the REWE article number) as the stable product identifier.
- Prices require a valid Market ID (see the pricing note above).
- The actor fails the run if zero products are returned, so a `SUCCEEDED` run always means you got data.

### Disclaimer

This actor scrapes publicly available data from shop.rewe.de for legitimate research and price-comparison purposes. Respect REWE's terms of service and applicable laws when using the data.

# Actor input Schema

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

Search for products by name or keyword (e.g., 'milch', 'kaffee', 'schokolade', 'bio'). German keywords work best.

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

Maximum number of products to return.

## `marktId` (type: `string`):

Optional REWE market id (delivery/pickup market). Prices, unit prices and promotions are market-specific on shop.rewe.de and only populate when a valid market id is supplied. Leave empty to scrape product catalog metadata (name, brand, category, image, article number, URL).

## `zip` (type: `string`):

Optional German postal code (e.g. '50667') used to label which market the prices belong to. Does not resolve a market id on its own — supply Market ID for prices.

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

Proxy settings. The default Apify Proxy works — the REWE products API is not geo-locked. Note: the datacenter pool has no DE-specific group, so do not set country to DE on datacenter (it 407s); use RESIDENTIAL if you need a DE exit.

## Actor input object example

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "REWE Scraper — German Supermarket Products & Prices",
        "description": "Scrape products, brands, categories, images and prices from shop.rewe.de, REWE's German online supermarket. Search by keyword, paginate, get clean JSON. No login or cookies.",
        "version": "0.1",
        "x-build-id": "NBlcJWHrAC7wShRed"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~rewe-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-rewe-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~rewe-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-rewe-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~rewe-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-rewe-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 (e.g., 'milch', 'kaffee', 'schokolade', 'bio'). German keywords work best."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 50
                    },
                    "marktId": {
                        "title": "Market ID (for prices)",
                        "type": "string",
                        "description": "Optional REWE market id (delivery/pickup market). Prices, unit prices and promotions are market-specific on shop.rewe.de and only populate when a valid market id is supplied. Leave empty to scrape product catalog metadata (name, brand, category, image, article number, URL)."
                    },
                    "zip": {
                        "title": "Postal Code",
                        "type": "string",
                        "description": "Optional German postal code (e.g. '50667') used to label which market the prices belong to. Does not resolve a market id on its own — supply Market ID for prices."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. The default Apify Proxy works — the REWE products API is not geo-locked. Note: the datacenter pool has no DE-specific group, so do not set country to DE on datacenter (it 407s); use RESIDENTIAL if you need a DE exit."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
