# Idealo Price Scraper (`s-r/idealo-scraper`) Actor

Look up any product EAN on idealo and get every live merchant offer: shop, total price, delivery and payment methods, plus the full price range. Germany and Austria. Each match is verified against the product page's own GTIN.

- **URL**: https://apify.com/s-r/idealo-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce
- **Stats:** 31 total users, 1 monthly users, 72.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Price Scraper, Offers and Prices by EAN

Turn any product barcode into the full idealo price-comparison listing. This idealo scraper takes an EAN/GTIN and returns its live merchant offers from idealo, shop name, total price, delivery estimate and accepted payment methods, across the German (idealo.de) and Austrian (idealo.at) marketplaces. No login, no idealo API key, no HTML parsing on your side.

It is built for price monitoring, repricing, and competitive intelligence where you already know the products you care about and need their idealo offers as clean structured JSON. Submit up to 5 EANs per run; each comes back as one product row with every one of its offers nested and the cheapest and most expensive total price pre-computed. Larger catalogues are handled by scheduling runs, which is also how you keep a price history rather than a single snapshot.

### What you get

- One dataset item per product EAN you submit, with the matching idealo product `title`, `brand`, canonical product `url`, `thumbnail`, and `idealo_sku`.
- A nested `offers` array, one entry per merchant, with `shop`, `total_price`, `position` in idealo's ranking, `delivery`, `shipping_included` and `payment_methods`, sorted cheapest first.
- **Every offer, not just the first page.** idealo's product page shows 20 offers and hides the rest behind a "show more" button; this Actor follows that through to the end, so a product with 45 sellers returns 45. `offer_count` is idealo's own total and `offers_returned` is what you received, so a short list is visible instead of silent.
- `min_total_price` and `max_total_price` straight from idealo's own totals, matching the range of the returned offers.
- **A verified EAN match.** idealo's search redirects to its closest product even when it does not hold your exact barcode, which is how a price lookup quietly returns the wrong product. Every match is checked against the product page's own GTIN. A page that publishes a different GTIN is reported as a miss, naming the GTIN it landed on in `matched_gtin`, rather than being passed off as your product.
- Coverage of both live idealo marketplaces: Germany (`idealo.de`) and Austria (`idealo.at`), selectable per run.
- An explicit `found` flag so a product idealo does not list is returned as a clear empty record, never a silent gap in your data. `ean_verified` separates a match idealo's own GTIN confirms from one it simply does not publish a code for.
- EUR pricing with the currency stated on every item.
- Up to 5 EANs per run, looked up in parallel. The limit is deliberate: each product is fetched in full, and a small run finishes in seconds instead of degrading into a partial one.

### Why scrape idealo price comparison data

idealo is the dominant price-comparison marketplace in the German-speaking market, aggregating offers from hundreds of merchants for the same product. For anyone selling, sourcing, or analysing consumer goods in Germany and Austria, the idealo product page is the single best snapshot of the live competitive price landscape for a given item.

The problem is access. idealo has no public offers API, the product pages are behind bot protection, and the listing for one product can carry dozens of merchant offers that change throughout the day. Scraping it reliably yourself means maintaining proxies, parsing a moving HTML target, and handling the German and Austrian sites separately. This actor does that work behind a stable API-backed pipeline so you receive normalized JSON keyed by the EAN you already have in your catalog.

Because the input is the EAN, the data joins directly back to your own product master, no fuzzy title matching, no manual mapping between your SKUs and idealo's.

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `eans` | array of strings | Yes | Product barcodes (EAN-8/EAN-13/GTIN, 8-14 digits), **maximum 5 per run**. Non-digit characters are stripped automatically. Duplicates are de-duplicated. |
| `country` | string (`de` or `at`) | No | Which idealo marketplace to query. `de` = idealo.de (default), `at` = idealo.at. |
| `concurrency` | integer (1-5) | No | How many of the run's EANs to look up in parallel. Default 5. |

Minimal input:

```json
{
  "eans": ["5702017416663"],
  "country": "de"
}
```

### Output

Each product is one dataset item. Example (trimmed to three offers):

```json
{
  "ean": "5702017416663",
  "country": "de",
  "site": "idealo.de",
  "found": true,
  "idealo_sku": 202283713,
  "title": "LEGO Icons - Botanical Collection - Wildblumenstrauß (10313)",
  "brand": null,
  "url": "https://www.idealo.de/preisvergleich/OffersOfProduct/202283713.html",
  "thumbnail": null,
  "availability": "InStock",
  "currency": "EUR",
  "ean_verified": true,
  "matched_gtin": "4242005218875",
  "offer_count": 20,
  "offers_returned": 20,
  "min_total_price": 90.9,
  "max_total_price": 150.12,
  "offers": [
    {
      "shop": "otto.de",
      "shop_id": "3040",
      "position": 1,
      "total_price": 90.9,
      "price_text": "90,90",
      "shipping_included": true,
      "shipping_cost_text": null,
      "delivery": "lieferbar - am nachsten Werktag bei dir",
      "payment_methods": ["Rechnung", "Lastschrift", "Vorkasse"],
      "offer_key": "195a631b5ed56680000e997125b2b868"
    },
    {
      "shop": "boomstore.de",
      "shop_id": "1449",
      "position": 2,
      "total_price": 97.46,
      "shipping_included": true,
      "delivery": "Lieferung: bis Mi. 09.09.",
      "payment_methods": ["Rechnung", "Lastschrift", "Vorkasse"]
    }
  ]
}
```

Only products idealo actually lists reach the dataset, so every dataset item is a real result. EANs idealo has no listing for are reported separately in the run's `OUTPUT` record under `notFound` (a list of EANs), free of charge, so you can reconcile your input against what was found.

### Use cases

**Repricing and Buy-Box strategy for German marketplaces.** If you sell on idealo, Amazon.de or your own shop, you need to know where your price sits against every other merchant on the same product. Pull your catalog's EANs through this idealo scraper on a schedule, read `min_total_price` and the per-seller `offers`, and feed your repricing engine the live competitive floor for Germany and Austria.

**Brand and MAP monitoring.** Brands enforcing minimum advertised pricing across the DACH region can watch every merchant offer for their products on idealo in one pass. The `shop` and `total_price` fields make it straightforward to flag any seller listing below an agreed threshold, with shipping already included in the comparison.

**Market and assortment research.** Analysts sizing a category can submit a basket of EANs and capture the spread between cheapest and most expensive offers (`min_total_price` to `max_total_price`), the depth of competition (`offer_count`), and availability across both the German and Austrian markets, useful inputs for launch pricing and channel decisions.

**Product data enrichment.** Marketplaces and aggregators that already hold EANs can enrich their records with idealo's canonical product title, image and live price range, keyed cleanly on the barcode with no title-matching guesswork.

### How it compares

| | Idealo Price Scraper (this actor) | Typical free idealo scrapers |
| --- | --- | --- |
| Pricing | Pay-per-event, pay only for products actually found | Free actor, but you pay unpredictable Apify compute |
| Input | EAN/GTIN, joins straight to your catalog | Often URL- or keyword-based |
| Markets | idealo.de and idealo.at | Usually idealo.de only |
| Match quality | Every EAN is checked against the product page's own GTIN, so a near-miss is reported as a miss | Trusts the search redirect, so a similar product can be returned as yours |
| Output | Offers nested per product, min/max total price computed | Raw rows, post-processing left to you |

Free idealo scrapers exist and work for one-off runs, but they bill Apify compute, so cost scales with run time rather than with results. This actor trades a small per-result fee for output you can bill and forecast, and for a match you can trust: you are charged for a resolved product, not for the attempt.

### Pricing

This actor is pay-per-event with two events: a small per-run **actor start** fee, and a **result** charge of $0.004 per product idealo actually returns (one dataset item). EANs with no idealo listing are reported in `OUTPUT.notFound` and are not charged. Apify automatically applies subscription-plan discounts (for example, Business and higher plans receive a 75% discount on the result price). All pricing is pay-per-event, so you only pay for results you receive, no per-compute-unit charges.

### Limits and gotchas

- **Only Germany and Austria are supported.** idealo discontinued its UK, France, Spain and Italy marketplaces in 2020. The actor exposes only `de` and `at` because those are the only idealo sites that return live data.
- **Lookup is by EAN/GTIN**, not by free-text search or product URL. If you do not have the barcode, resolve it first.
- **A product not listed on idealo is not an error.** Its EAN is returned in `OUTPUT.notFound` rather than the dataset, and is not charged.
- **Prices are a point-in-time snapshot.** idealo offers change throughout the day; schedule repeat runs if you need a price history.
- **Free Apify plans are capped at 10 results per run.** Upgrade your Apify plan or split work across runs to go beyond that. Paying plans are uncapped.
- **Currency is EUR** for both markets.
- **Brand is sometimes null**, idealo does not expose a brand field on every product.

### FAQ

**Can I scrape idealo prices without an idealo API key?** Yes. idealo has no public offers API; this actor handles access for you and returns structured JSON. You supply only EANs.

**Why is `ean_verified` false on a product that clearly matched?** Roughly half of idealo's products publish no GTIN on the page, so there is nothing to confirm the match against. That is missing confirmation, not a wrong match: the product was still resolved from your EAN by idealo's own index. Where a page does publish a GTIN and it differs from yours, the item comes back with `found: false` instead.

**Does it cover idealo.at (Austria) as well as idealo.de?** Yes, set `country` to `at` for the Austrian marketplace or `de` for Germany. Each market is priced independently by its merchants, so the same EAN can return different offers.

**Why do idealo.fr, idealo.co.uk, idealo.es and idealo.it not work?** idealo closed those international marketplaces in 2020 and operates only in Germany and Austria today, so there is no live data to return for them.

**How do I get the cheapest idealo price for a product?** Read `min_total_price` on each item. It is idealo's own lowest total for the product across every offer it lists, and it matches the cheapest entry in the `offers` array.

**Can I look up many products in one run?** Up to 5 EANs per run. The actor de-duplicates them and looks them up concurrently. Anything beyond the fifth is left unprocessed and listed by name in the run's `errors` record, so you know exactly what to send next. For a bigger catalogue, schedule repeated runs.

### Related Actors

- [Google Reviews Scraper](https://apify.com/s-r/google-reviews), product reviews and ratings by SKU.
- [Price Scraper](https://apify.com/s-r/price-scraper---extract-prices-a), extract prices from arbitrary product pages.
- [Shopify Products Scraper](https://apify.com/s-r/shopify-products), full storefront catalogs from any Shopify shop.

# Actor input Schema

## `eans` (type: `array`):

One or more product barcodes (EAN-8/EAN-13/GTIN, 8-14 digits), up to 5 per run. Each is looked up on idealo and returns its live merchant offers. Non-digit characters are stripped automatically. Split a longer catalogue across runs.

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

Which idealo marketplace to query. idealo operates only in Germany (idealo.de) and Austria (idealo.at); it closed its UK/France/Spain/Italy sites in 2020.

## `concurrency` (type: `integer`):

How many of the run's EANs to look up in parallel. Each lookup is several requests to idealo, so lower this if you see incomplete offer lists.

## Actor input object example

```json
{
  "eans": [
    "4242005218875"
  ],
  "country": "de",
  "concurrency": 5
}
```

# Actor output Schema

## `results` (type: `string`):

One item per product idealo lists. Each item nests the live seller offers under 'offers'. EANs idealo does not list, and EANs whose redirect landed on a different GTIN, are reported in the run's OUTPUT.notFound instead.

## `output` (type: `string`):

OUTPUT record with the run's counts and status flags.

## `errors` (type: `string`):

Failures with a code and a redacted message. Absent when the run had none.

# 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 = {
    "eans": [
        "4242005218875"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/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 = { "eans": ["4242005218875"] }

# Run the Actor and wait for it to finish
run = client.actor("s-r/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 '{
  "eans": [
    "4242005218875"
  ]
}' |
apify call s-r/idealo-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/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/WoRHXxVSK8QCaZkQq/builds/YVAwgL0KPt2wYhUFK/openapi.json