# Idealo Scraper $2.5/1K💰 | Offers | Price History | 6 Markets (`ahmed_jasarevic/idealo-scraper`) Actor

Extract idealo price comparison data from 6 European markets: per-merchant offers with shipping and total, min/max/avg prices, ratings, specs and 3-month price history. Look up by search term, EAN/GTIN, ID, URL or category. An affordable alternative to building your own idealo scraper.

- **URL**: https://apify.com/ahmed\_jasarevic/idealo-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 product scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Idealo Scraper — Prices, Offers & Price History for 6 European Markets

Extract **idealo price comparison data** — prices, per-merchant offers and 3-month price history from idealo.de, idealo.at, idealo.co.uk, idealo.fr, idealo.it and idealo.es — for **price monitoring, market research and repricing** without an idealo API key.

### Main Use Cases

- **Competitor price monitoring** — track how merchant prices and offer rankings change over time across Germany, Austria, UK, France, Italy and Spain
- **Price history analysis** — 3-month price trends with average/lowest/highest statistics for every product
- **EAN / GTIN price lookup** — turn barcodes into structured price-comparison data for catalog matching and repricing
- **Product market research** — build price and specification databases for electronics, home goods and more from one of Europe's largest price-comparison portals
- **Merchant offer tracking** — per-shop prices, shipping costs, total price, condition, availability, delivery time, payment methods and return policy
- **Cross-market price parity** — compare the same product across all six idealo marketplaces, each with localized pricing and offers

### How It Works

This actor queries idealo, one of Europe's largest price-comparison portals. You supply any combination of **search terms, EAN/GTIN barcodes, product URLs, product IDs or category URLs**. The actor resolves them to idealo product listings and returns structured JSON: product metadata, min/max/average prices, the full per-merchant offer list, technical specifications, ratings and — optionally — 3-month price history.

Idealo is protected by **Akamai Bot Manager**, and its product pages are ~600 KB of server-rendered HTML while the offer-list JSON equivalents do not exist. This actor therefore uses a lightweight `CheerioCrawler` (plain HTTP, no browser) routed through the **Apify proxy** (residential group recommended) to bypass the IP-based block. It paginates search results beyond the first ~50 products via idealo's own internal search API, and fetches price history from the same JSON API idealo's frontend uses.

**Fast mode:** if you only need prices, brand, category, images and energy class, enable `fastData: true` — the actor then uses idealo's compact JSON API (~1 KB per product instead of ~600 KB of HTML), which is faster and ~600× more efficient on proxied connections.

### Idealo Price Data Without an Official API

Idealo offers no public API for consumers — its merchant interfaces (PWS) only let sellers upload their own offers. There is no endpoint for reading the competitive offer list programmatically. This actor fills that gap: it extracts the same publicly visible price-comparison data a user sees on the site, in a normalized JSON structure you can feed straight into a database, dashboard or repricing workflow.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `searchQueries` | `string[]` | — | Free-text search terms, e.g. `["iPhone 15", "Samsung TV"]`. One crawl per term. |
| `productUrls` | `string[]` | — | Full idealo product URLs. In fast mode, the product ID is extracted from the URL. |
| `productIds` | `string[]` | — | Numeric idealo product IDs, resolved to product pages automatically. |
| `eanGtins` | `string[]` | — | EAN/GTIN/UPC barcodes (8–14 digits), each searched on idealo; best-matching product scraped. |
| `categoryUrls` | `string[]` | — | Full idealo category URLs; all products on the page are scraped. |
| `country` | `string` | `DE` | Marketplace: `DE`, `AT`, `GB`, `FR`, `IT` or `ES`. |
| `maxResults` | `int` | `50` | Max products per run (cap 500). Free users are capped at 10. |
| `maxOffersPerProduct` | `int` | `20` | Max merchant offers extracted per product (cap 100). |
| `includePriceHistory` | `bool` | `true` | Fetch 3-month price history + min/avg/max statistics. Adds one price-history charge event per product when data is fetched. |
| `fastData` | `bool` | `false` | Use the compact JSON API instead of the full HTML page. No offers/specs/ratings in this mode. |
| `proxyConfiguration` | `object` | Apify proxy, `BUYPROXIES94952` | Proxy settings via the Apify proxy editor. Residential groups work best against Akamai. Set `useApifyProxy: false` to run without proxy. |

```json
{
  "searchQueries": ["iPhone 15"],
  "eanGtins": ["4009803341163"],
  "country": "DE",
  "maxResults": 20,
  "maxOffersPerProduct": 10,
  "includePriceHistory": true
}
```

### Output

One dataset item per product:

| Field | Description |
|---|---|
| `productId`, `title`, `brand`, `thumbnail`, `images`, `productUrl` | Product identity and media |
| `category` | Category path (breadcrumb in full mode; `mainCat › shortCat` in fast mode) |
| `rating`, `reviewCount` | User rating and review count (full mode) |
| `priceMin`, `priceMax`, `priceAvg`, `offersCount` | Price summary across offers |
| `offers` | Per-merchant offers: seller, price, shipping, total (price + shipping — the value idealo ranks by), condition, availability/delivery, shipping provider, return policy, payment methods, shop rating |
| `specs` | Technical specification key/value pairs from the datasheet (full mode) |
| `priceHistory` | `period: "3M"`, daily `{x, y}` price points, `statistics` with average/lowest/highest price |
| `availability`, `energyClass`, `categoryId` | Populated in fast mode, `null` in full mode |
| `mode` | `"full"` (HTML) or `"fast"` (JSON API) |
| `sourceQuery`, `scrapedAt` | Which input produced the item and when |

#### Example output (full mode)

```json
{
  "productId": "207562448",
  "title": "Apple iPhone 15 128GB",
  "brand": "Apple",
  "thumbnail": "https://cdn.idealo.com/folder/Product/207562/4/207562448/s1_produktbild_max.jpg",
  "images": ["https://cdn.idealo.com/..."],
  "productUrl": "https://www.idealo.de/preisvergleich/OffersOfProduct/207562448_-iphone-15-128gb-apple.html",
  "category": "5G Handy",
  "rating": 4.7,
  "reviewCount": 312,
  "priceMin": 629.0,
  "priceMax": 759.0,
  "priceAvg": 689.5,
  "offersCount": 8,
  "offers": [
    {
      "seller": "Amazon",
      "offerTitle": "Apple iPhone 15 128GB",
      "price": 629.0,
      "shipping": 0,
      "total": 629.0,
      "condition": "new",
      "availability": "Lieferung in 1-2 Werktagen",
      "shippingProvider": "DHL",
      "returnPolicy": "kostenloser Rückversand",
      "paymentMethods": ["PayPal", "Kreditkarte"],
      "shopRating": 4.8,
      "shopReviewCount": 1240,
      "offerUrl": "https://www.idealo.de/relocator/relocate?categoryId=..."
    }
  ],
  "specs": { "Displaygröße": "6,1 Zoll", "Prozessor": "Apple A16 Bionic", "RAM": "6 GB" },
  "priceHistory": {
    "period": "3M",
    "data": [{ "x": "2026-06-10", "y": 649.0 }],
    "statistics": { "avgPrice": 689.5, "lowestPrice": 629.0, "highestPrice": 759.0 }
  },
  "availability": null,
  "energyClass": null,
  "categoryId": null,
  "mode": "full",
  "sourceQuery": "iPhone 15",
  "scrapedAt": "2026-09-09T18:40:00.000Z"
}
```

In **fast mode** (`mode: "fast"`) the item contains `title`, `brand`, `thumbnail`, `images`, `productUrl`, `category`, `priceMin`, `availability`, `energyClass`, `categoryId` and optional `priceHistory`; `offers`, `specs`, `rating`, `reviewCount`, `priceMax`, `priceAvg`, `offersCount` are `null`/empty.

### Integrations & Automation

Run the actor from any Apify client (JavaScript, Python, REST API) or trigger it via the **Apify webhooks / Zapier / Make** integrations on a schedule. Recommended cadences:

- **Price monitoring / repricing feeds** — daily runs (idealo prices change throughout the day; the offer list idealo ranks by is volatile)
- **Weekly market research** — weekly category or search-term crawls for trend tracking
- **Monthly price history refresh** — monthly runs on a fixed product ID list, combined with the built-in 3-month history field

Recurring, scheduled usage also improves the actor's Store recommendations and gives you continuously comparable datasets.

### Related Actors

- [Idealo Scraper & Price Data API](https://apify.com/pricepirate/idealo-price-data-api) — the most-used idealo price data actor on Apify (per-query lookups, AI offer matching)
- [Idealo Price Scraper (s-r)](https://apify.com/s-r/idealo-scraper) — EAN-only lookup for idealo.de and idealo.at with pre-computed min/max total price
- [Idealo Listing Scraper](https://apify.com/powerai/idealo-listing-scraper) — idealo.de product listing extraction with pagination
- [Idealo.de – Price Comparison Scraper](https://apify.com/abotapi/idealo-de-price-comparison-scraper) — idealo.de product detail with rating breakdowns and reviews
- [Idealo Product & Offer Scraper](https://apify.com/axlymxp/idealo-product-offer-scraper) — 6-market offer extraction with all-offers mode

### FAQ

#### Is this an official idealo API?

No. Idealo offers no public API for reading competitive price data. This actor extracts the same **publicly visible** data from idealo's websites and JSON endpoints — no login, no merchant interface, no credentials required.

#### Can I scrape idealo prices without an idealo API key?

Yes. That is exactly what this actor does. It needs no idealo API key, no cookies and no login — only Apify credentials (and a proxy for reliable volumes, because idealo is protected by Akamai).

#### How do I get the cheapest idealo price for a product?

Read `priceMin` (lowest listed price) and compare `total` across the `offers` array — total is price **plus shipping**, which is the number idealo actually ranks offers by. `priceHistory.statistics.lowestPrice` shows the lowest price over the last 3 months.

#### Does this actor support idealo price history?

Yes. With `includePriceHistory: true` (default), each product includes a 3-month `priceHistory` object with daily price points and average/lowest/highest statistics from idealo's own price-chart JSON API.

#### Why are some fields null in full mode?

`availability`, `energyClass` and `categoryId` are only exposed by idealo's compact JSON API, which full mode does not call (full mode parses the HTML page for offers/specs/ratings instead). If you need those three fields, enable `fastData: true` — you trade the offers/specs/rating detail for the JSON basics.

#### Why use this actor instead of the official API?

There is no official API to use — idealo's merchant interfaces (PWS) manage only your *own* offers and DirectKauf orders. For reading the competitive market view (every merchant's price, shipping, total and ranking on a listing), a scraper is the only option, and this one is among the most cost-efficient: **$0.0025 per product** with optional **$0.001 per product** for 3-month price history.

#### What are the alternatives to this actor?

The Apify Store has several idealo actors (see Related Actors above); the closest is `pricepirate/idealo-price-data-api` at **$0.005 per query** (2× this actor's per-result price) plus general scraping APIs like ScrapingBee or Oxylabs. For DACH-wide monitoring, dedicated SaaS platforms (4pricing, Dealavo) also aggregate idealo data but require subscriptions.

#### What is the free tier?

Free Apify accounts are capped at **10 products per run**. The actor start charge is $0.0005; paying users can request up to `maxResults: 500`.

### SEO Keywords

idealo scraper, idealo api, idealo price comparison data, idealo price history, idealo price tracker, idealo offers, ean lookup idealo, gtin lookup europe, idealo alternative, price monitoring germany, preisvergleich data, dach price comparison, merchant offers scraper, product price database, 6 european markets, idealo.de data, multi-market price data, repricing data supplier, barcode price lookup, api alternative for price data, price history statistics, lowest price tracking

### For AI Agents & LLM Apps

This actor is callable via the Apify MCP server and the Apify REST API, so an agent can run it directly.

**Purpose:** given search terms, EANs/GTINs, product URLs, product IDs or category URLs on an idealo marketplace, return structured product data (prices, merchant offers, specs, ratings, 3-month price history) as one dataset item per product.

**Minimal working input:**

```json
{ "searchQueries": ["iPhone 15"], "maxResults": 10 }
```

**Variant — EAN lookup with price history:**

```json
{ "eanGtins": ["4009803341163"], "country": "DE", "includePriceHistory": true, "maxResults": 5 }
```

**Variant — fast/cheap mode (no offers/specs/ratings):**

```json
{ "searchQueries": ["Samsung TV"], "country": "DE", "fastData": true, "includePriceHistory": false, "maxResults": 20 }
```

**Output fields:** `productId`, `title`, `brand`, `thumbnail`, `images`, `productUrl`, `category`, `rating`, `reviewCount`, `priceMin`, `priceMax`, `priceAvg`, `offersCount`, `offers[].{seller, offerTitle, price, shipping, total, condition, availability, deliveryTime, shippingProvider, returnPolicy, paymentMethods, shopRating, shopReviewCount, offerUrl}`, `specs`, `priceHistory.{period, data[{x,y}], statistics.{avgPrice, lowestPrice, highestPrice}}`, `availability`, `energyClass`, `categoryId`, `mode`, `sourceQuery`, `scrapedAt`.

**Behaviors an agent should know:**

- `mode` distinguishes the two output shapes: `"full"` (HTML parse: offers/specs/ratings; `availability`/`energyClass`/`categoryId` are `null`) vs `"fast"` (JSON API: basics only; offers/specs/ratings empty). Set `fastData: true` deliberately if you only need prices/brand/category/images.
- `includePriceHistory` defaults to **true** and adds an extra `price-history` charge per product **only when history data was actually fetched**; set it to `false` to minimize cost.
- `maxResults` is capped at **500**; free-tier accounts are hard-capped at **10** products per run.
- `maxOffersPerProduct` caps the offers list (default 20, max 100); first N visible offers only.
- `country` selects the marketplace everywhere (search URL, product URL, price-history and product-info JSON endpoints); product URLs passed in `productUrls` should belong to the same country.
- Multiple input arrays can be combined in one run; if no input is provided the actor exits with a warning. Each search term / EAN / category URL produces its own crawl.
- Akamai Bot Manager may block datacenter IPs — if a run returns empty results, rerun with a residential proxy group (default: `BUYPROXIES94952`) or a fresh session; the crawler automatically retires blocked sessions for a new proxy IP.

**Billing:** pay-per-event — `$0.0005` actor start, `$0.0025` per product pushed, `$0.001` per product when price history is fetched (both event charges apply only when the Monetization/pay-per-event events are enabled, per Apify MI).

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by idealo Internet GmbH**. It accesses only **publicly visible pages and JSON endpoints** on idealo's websites — no login bypass, no CAPTCHA solving, no merchant-account access. The actor extracts what any visitor can see; users are responsible for complying with idealo's Terms of Service and with applicable data-protection law (e.g. GDPR) when storing or processing the extracted data, including personal or commercial data of listed merchants. Use respectfully and respect rate limits.

# Actor input Schema

## `searchQueries` (type: `array`):

Free-text search terms to look up on idealo.de, e.g. "iPhone 15", "Samsung TV". Each term produces a search-results crawl.

## `productUrls` (type: `array`):

Full idealo.de product URLs, e.g. https://www.idealo.de/preisvergleich/OffersOfProduct/207562448\_-iphone-15-128gb-apple.html

## `productIds` (type: `array`):

Numeric Idealo product IDs, e.g. 207562448. Resolved to product pages automatically.

## `eanGtins` (type: `array`):

EAN/GTIN/UPC barcodes (8-14 digits). Each barcode is searched on idealo and the best-matching product is scraped.

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

Full idealo.de category URLs, e.g. https://www.idealo.de/preisvergleich/ProductCategory/3751.html (Laptops). All products on the category page are scraped.

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

Idealo marketplace to query. Affects the domain used for search and product URLs.

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

Maximum number of products to scrape in total. Free users are capped at 10.

## `maxOffersPerProduct` (type: `integer`):

Maximum number of merchant offers to extract per product (the first N offers shown on the product page).

## `includePriceHistory` (type: `boolean`):

Fetch the 3-month price history (JSON API) for each product, including min/max/avg price statistics. When enabled, one 'price-history' charge event is billed per product via Apify MI (pay-per-event pricing) if configured.

## `fastData` (type: `boolean`):

Skip the full product HTML page (~600 KB per product) and use idealo's compact JSON API (~1 KB per product) instead. Returns: title, brand, category, min/minTotal price, images, availability, energy class + optional price history. Does NOT return the merchant offers list, specs table or ratings.

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

Select proxies to be used by your crawler. Idealo is protected by Akamai bot management, so a residential proxy group is strongly recommended.

## Actor input object example

```json
{
  "searchQueries": [
    "iPhone 15"
  ],
  "productUrls": [],
  "productIds": [],
  "eanGtins": [],
  "categoryUrls": [],
  "country": "DE",
  "maxResults": 50,
  "maxOffersPerProduct": 20,
  "includePriceHistory": true,
  "fastData": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}
```

# Actor output Schema

## `result` (type: `string`):

Products found on idealo for the requested search terms, product URLs/IDs, EANs or category URLs.

# 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 = {
    "searchQueries": [
        "iPhone 15"
    ],
    "productUrls": [],
    "productIds": [],
    "eanGtins": [],
    "categoryUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "BUYPROXIES94952"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/idealo-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 = {
    "searchQueries": ["iPhone 15"],
    "productUrls": [],
    "productIds": [],
    "eanGtins": [],
    "categoryUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["BUYPROXIES94952"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/idealo-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "iPhone 15"
  ],
  "productUrls": [],
  "productIds": [],
  "eanGtins": [],
  "categoryUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}' |
apify call ahmed_jasarevic/idealo-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/idealo-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/yUuVlBzpzLL6slbPk/builds/aleMBe1LkIHhWrSct/openapi.json