# Idealo Price Scraper: All Shop Offers, 6 Countries, No Login (`cliqtomedia/idealo-price-scraper`) Actor

Search idealo or paste product URLs and get every shop offer per product: price, shipping, total price, delivery time, shop rating and shop link, plus best price, category, brand, GTIN and rating. idealo.de, .at, .fr, .it, .es and .co.uk. No login.

- **URL**: https://apify.com/cliqtomedia/idealo-price-scraper.md
- **Developed by:** [Cliqto Media](https://apify.com/cliqtomedia) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.80 / 1,000 product with offers

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Idealo Price Scraper reads idealo price comparison pages and returns every shop offer for a product: shop, price, shipping, total price, delivery time, shop rating and shop link. It works on idealo.de, idealo.at, idealo.fr, idealo.it, idealo.es and idealo.co.uk.

Use it to track prices, compare shops or check your own shop against other sellers. The smallest run is one search word, for example `airpods pro`, and it gives you 10 products with their offers in about 30 seconds after the run starts. No login, no API key.

![Idealo Price Scraper: search idealo or paste product URLs, get each shop offer with price, shipping and total price in 6 countries](https://api.apify.com/v2/key-value-stores/qTgofY50Zo5kdYAEL/records/README-BANNER-20261014.png)

### Table of contents

- [What it does](#what-it-does)
- [Quick start](#quick-start)
- [Use cases](#use-cases)
- [Input](#input)
- [Output](#output)
- [Pricing and limits](#pricing-and-limits)
- [API, export and integrations](#api-export-and-integrations)
- [Troubleshooting](#troubleshooting)
- [FAQ](#faq)
- [Support](#support)

### What it does

idealo is a price comparison site. For one product it lists many shops and their prices. This Actor opens those pages for you and saves the data as rows.

- **Search mode:** you type keywords. The Actor takes the products from the first results page of each search, in idealo's order, and reads each product page.
- **Products mode:** you paste idealo product URLs or product IDs. The Actor reads exactly those products. URLs can come from different countries in one run.

One dataset row = one product. The row has product data (title, brand, GTIN/EAN, category, best price, highest price, number of offers, rating) and a list `offers` with the shops.

#### Good fit

- Watch the price of your products in several countries every day.
- See all shops that sell a product, with shipping and total price, not only the cheapest one.
- Find a product's GTIN/EAN, brand and category from a keyword.

#### Not a fit / limits

- Only the 6 idealo sites above. Other countries and other price comparison sites are not supported.
- Search mode reads only the **first results page** of each search. Single-shop offers without an idealo price comparison page are skipped.
- Up to 200 products and up to 200 offers per product in one run (20 offers per product by default).
- Prices are what idealo shows at the time of the run. Shops can change prices at any time.
- Used and refurbished offers are not in the offer list (idealo shows them separately).

### Quick start

1. Open the **Input** tab.
2. Keep **What to scrape** = `Search` and the prefilled query `airpods pro`.
3. Keep **idealo site** = `idealo.de (Germany)` and **Max products** = `10`.
4. Click **Start**.
5. Open the **Output** tab. The `Products` view shows one row per product; the `All offers` view shows one row per shop offer.

Expected result: 10 AirPods products, each with up to 20 shop offers, in about 30 seconds.

### Use cases

| Buyer job | Input path | Output entity | Key fields | Next integration |
| --- | --- | --- | --- | --- |
| Track prices of my product list | `mode: products`, `productUrls` | product row | `bestPrice`, `offerCount`, `offers[].totalPrice` | Schedule + Google Sheets or webhook |
| Compare shops for one product | `productUrls`, `maxOffersPerProduct: 100` | offers | `offers[].shop`, `price`, `shipping`, `availability` | CSV / Excel export |
| Find products and EANs by keyword | `mode: search`, `queries` | product row | `title`, `gtin`, `brand`, `category` | API / JSON |
| Compare one product across countries | the same product ID as URLs on several idealo sites | product row per site | `domain`, `currency`, `bestPrice` | API / JSON |

### Input

#### Input fields

| Field | Plain name | Type | Required | Default / prefill | Allowed values | Effect | Example | Recommendation |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `mode` | What to scrape | string | no | default and prefill `search` | `search`, `products` | Search by keywords or read pasted products | `"products"` | If you send only `productUrls` by API, products mode is used |
| `queries` | Search queries | array of strings | in search mode | prefill `["airpods pro"]` | up to 20 | One idealo search per query | `["airpods pro", "galaxy s25"]` | Use product-like words, not one shop's offer title |
| `productUrls` | Product URLs or IDs | array of strings | in products mode | empty | up to 200; idealo product URLs of the 6 sites or numeric IDs | Reads these product pages | `["https://www.idealo.fr/prix/207671730/apple-airpods-pro-3.html", "207671730"]` | Bare IDs are read on the site in `domain` |
| `domain` | idealo site | string | no | default and prefill `de` | `de`, `at`, `fr`, `it`, `es`, `co.uk` | Site for searches and bare IDs | `"fr"` | URLs always use their own site |
| `maxItems` | Max products | integer | no | prefill `10`; empty = 10 for search, all pasted products in products mode | 1–200 | Stops after this many products | `50` | Main cost control |
| `maxOffersPerProduct` | Max offers per product | integer | no | default `20` | 0–200 | Offers per product row | `100` | 0 = product data and best price only |
| `proxyConfiguration` | Proxy | object | no | no proxy | Apify Proxy settings (automatic or datacenter groups; residential is not supported) | Sends requests through a proxy | `{"useApifyProxy": true}` | Turn on only if runs report a block |

Empty or missing queries in search mode, or no product URLs in products mode, fail the run with a clear message before any idealo request. Duplicate products are read once and counted in `RUN_SUMMARY` as `duplicatesSkipped`. Invalid URLs (not idealo, unsupported country) become free `error` rows; the run continues.

#### Interacting settings

| When | Input A | Input B | Effective behavior | Example | Cost/result effect |
| --- | --- | --- | --- | --- | --- |
| Search mode | `queries` | `maxItems` | Queries run in order until `maxItems` products are saved | 3 queries, `maxItems: 10` | Later queries may not run |
| Products mode | `productUrls` | `maxItems` | Only the first `maxItems` inputs are read | 200 URLs, `maxItems: 50` | 50 products read |
| Products mode | `productUrls` (URL) | `domain` | A URL keeps its own site; `domain` is only for bare IDs | `.fr` URL + `domain: de` | Read on idealo.fr |
| More than 20 offers | `maxOffersPerProduct` | timeout | Every 20 offers after the first 20 is one more page | `maxOffersPerProduct: 200` | One extra `offer-page` event per page; longer run |

#### Input examples

##### Search one keyword on idealo.de

```json
{
  "mode": "search",
  "queries": ["airpods pro"],
  "domain": "de",
  "maxItems": 10
}
```

Expected behavior: one search, then the first 10 products of the results page.
Expected output: 10 rows with `title`, `bestPrice`, `offerCount` and up to 20 `offers`.
Limit or cost note: Actor start + 1 country site + 1 search query + 10 products.

##### Products from several countries

```json
{
  "mode": "products",
  "productUrls": [
    "https://www.idealo.de/preisvergleich/OffersOfProduct/207671730_-airpods-pro-3-apple.html",
    "https://www.idealo.fr/prix/207671730/apple-airpods-pro-3.html",
    "https://www.idealo.co.uk/compare/207671730/apple-airpods-pro-3.html"
  ],
  "maxOffersPerProduct": 60
}
```

Expected behavior: the same product on 3 sites; prices in EUR for .de/.fr and GBP for .co.uk.
Expected output: 3 rows, each with up to 60 offers.
Limit or cost note: Actor start + 3 country sites + 3 products + up to 2 extra offer pages per product. Products are read site by site, so the order of rows can differ from your list.

### Output

#### Output fields

| Field | Meaning | Type | Can be empty? | Example / enum | Source / notes |
| --- | --- | --- | --- | --- | --- |
| `status` | Result of this row | string | no | `complete`, `partial`, `not_found`, `error` | See "Output entities" below |
| `productId` | idealo product ID | string | null for invalid input | `"207671730"` | Same ID on all idealo sites |
| `title` | Product name | string | yes | `"Apple AirPods Pro 3"` | Product page |
| `url` | Product page | string | no | idealo URL | Your input text for invalid entries |
| `domain` | Site of this row | string | no | `"de"` | |
| `category`, `categoryId` | Category | string | yes | `"Kopfhörer"`, `"2520"` | Category name in the site's language |
| `brand` | Brand | string | yes | `"Apple"` | |
| `gtin` | GTIN / EAN | string | yes | `"0195950543650"` | Only when idealo lists one |
| `imageUrl` | Product image | string | yes | idealo CDN URL | |
| `currency` | Currency | string | yes | `"EUR"`, `"GBP"` | |
| `bestPrice` | Lowest offer price (no shipping) | number | yes | `193` | null when idealo has no new offers |
| `highestPrice` | Highest offer price | number | yes | `281.95` | For all offers on the site, not only returned ones |
| `offerCount` | Number of offers on idealo | integer | yes | `57` | Can be more than `offersReturned` |
| `offersReturned` | Offers in this row | integer | no | `20` | Up to `maxOffersPerProduct` |
| `rating`, `ratingCount` | Product rating | number, integer | yes | `4.6`, `10` | null when not rated |
| `offers[].position` | Rank in idealo order | integer | no | `1` | Cheapest item price first |
| `offers[].shop`, `shopId` | Shop | string | yes | `"kaufland.de"`, `"26895"` | Marketplace name for marketplace offers |
| `offers[].marketplaceSeller` | Seller inside a marketplace | string | yes | `"pricerush"` | null for direct shop offers |
| `offers[].offerTitle` | Title used by the shop | string | yes | | |
| `offers[].price` | Item price | number | yes | `193` | Without shipping |
| `offers[].shipping` | Shipping cost | number | yes | `9.99` | `0` = free shipping; null = the shop does not state it |
| `offers[].totalPrice` | Price with shipping | number | yes | `202.99` | null when shipping is unknown |
| `offers[].availability` | Delivery text | string | yes | `"Lieferung: bis Sa. 17.10."` | As shown, in the site's language |
| `offers[].shopRating`, `shopRatingCount` | Shop rating | number, integer | yes | `4.5`, `56444` | |
| `offers[].url` | Link to the offer | string | yes | idealo redirect URL | Opens the shop page |
| `searchQuery`, `searchPosition` | How the product was found | string, integer | yes | `"airpods pro"`, `1` | Search mode only |
| `input` | Your URL or ID | string | yes | `"207671730"` | Products mode only |
| `error` | Why the row is not complete | string | yes | | null for complete rows |
| `source`, `fetchedAt` | Source and time | string | no | `"idealo"`, ISO time | |

#### Output entities and surfaces

| Situation | Dataset/API/KVS/live view | Result shape | User action |
| --- | --- | --- | --- |
| Normal item | Dataset, views `Products` and `All offers` | `status: complete`, product fields and `offers` | Export or use the fields |
| Product without new offers | Dataset | `complete`, `offerCount: 0`, `bestPrice: null`, empty `offers` | idealo lists only used offers or no shops now |
| Search without products | Key-value store `RUN_SUMMARY` | no row; query in `queriesWithoutResults` | Try a more general query |
| Product does not exist | Dataset | `status: not_found`, `error` text | Check the ID or URL |
| Invalid input entry | Dataset | `status: error`, `productId: null`, your text in `input` | Fix the URL |
| Product page could not be read | Dataset | `status: error`, `error` text, not charged; 3 such pages in a row stop the run with `SOURCE_ERROR` | Run again later |
| Some offers could not be read | Dataset | `status: partial`, offers read so far, `error` | Run the product again |
| idealo blocked or did not answer | `RUN_SUMMARY` (`stopReason: SOURCE_ERROR`), run status Failed | rows saved before the problem stay | Run again later or turn on the proxy |

`RUN_SUMMARY` also has counts (`complete`, `partial`, `notFound`, `error`, `saved`, `offers`, `duplicatesSkipped`), `warnings` and `stopReason` (`TIMEOUT`, `CHARGE_LIMIT`, `CANCELLED` or null). Its `domain` field is the `domain` from your input; rows can come from other sites when you paste URLs.

#### Output example

```json
{
  "status": "complete",
  "productId": "207671730",
  "title": "Apple AirPods Pro 3",
  "url": "https://www.idealo.de/preisvergleich/OffersOfProduct/207671730_-airpods-pro-3-apple.html",
  "domain": "de",
  "category": "Kopfhörer",
  "categoryId": "2520",
  "brand": "Apple",
  "gtin": "0195950543650",
  "currency": "EUR",
  "bestPrice": 193,
  "highestPrice": 281.95,
  "offerCount": 57,
  "offersReturned": 20,
  "rating": 4.6,
  "ratingCount": 10,
  "offers": [
    {
      "position": 1,
      "shop": "kaufland.de",
      "shopId": "26895",
      "marketplaceSeller": "pricerush",
      "price": 193,
      "shipping": 9.99,
      "totalPrice": 202.99,
      "currency": "EUR",
      "availability": "Lieferung: bis Sa. 17.10.",
      "shopRating": 4.5,
      "shopRatingCount": 56444
    }
  ],
  "searchQuery": "airpods pro",
  "searchPosition": 1,
  "input": null,
  "error": null,
  "source": "idealo"
}
```

This example is trimmed: one of 20 offers, and some fields (`imageUrl`, `offerTitle`, `url`, `fetchedAt`) are left out. `null` means idealo does not show the value; it never means 0. For example, `shipping: null` means the shop does not state its shipping cost on idealo ("see shop").

### Pricing and limits

#### Pricing unit

This Actor uses pay per event. You pay only for these events; platform usage is included.

| Event | Price | When |
| --- | ---: | --- |
| Actor start | $0.009 per GB of memory ($0.018 per run at 2 GB) | Once per run |
| Country site | $0.0045 | Once for each idealo country site the run opens (idealo.de, .fr, …), after its first successful page |
| Product with offers | $0.0045 (Free plan), $0.0042 (Bronze), $0.004 (Silver), $0.0038 (Gold and higher) | Each `complete` or `partial` row, with up to 20 offers |
| Extra offer page | $0.0015 | Each further 20 offers that were read (only when `maxOffersPerProduct` is above 20) |
| Search query | $0.002 | Each search results page read, also when it has no products |
| Product not found | $0.002 | Each `not_found` row |

Invalid input entries (`error` rows) are free. A run with a search that finds nothing costs the start fee, one country site and one search query, about $0.0245. If idealo blocks the run, you pay only for events that happened before the stop.

Set **Max total charge** in run options to cap the cost. The Actor stops before it goes over the cap; rows that were already saved stay (`stopReason: CHARGE_LIMIT`).

#### Cost examples

Free plan prices, 2 GB memory.

| Scenario | Input scope | Events | Base charge | Optional charge | Stop/cap behavior |
| --- | --- | ---: | ---: | ---: | --- |
| Prefill | 1 query, 10 products, 20 offers | start + 1 site + 1 query + 10 products | $0.018 + $0.0045 + $0.002 + $0.045 = $0.0695 | none | — |
| 100 products | 10 queries on one site, 100 products | start + 1 site + 10 queries + 100 products | $0.018 + $0.0045 + $0.02 + $0.45 = $0.4925 | none | Max total charge stops earlier |
| 6 countries | 6 product URLs, one per idealo site | start + 6 sites + 6 products | $0.018 + $0.027 + $0.027 = $0.072 | none | — |
| Deep offer list | 1 product, `maxOffersPerProduct: 200`, 57 offers on idealo | start + 1 site + 1 product + 2 extra pages | $0.018 + $0.0045 + $0.0045 = $0.027 | $0.003 | Only pages that exist are read |
| Nothing found | 1 query without products | start + 1 site + 1 query | $0.0245 | none | — |

#### Limits

- Up to 20 search queries and 200 product URLs or IDs per run; at most 200 products saved.
- Up to 200 offers per product.
- Default timeout is 900 seconds; 200 products with 20 offers take about 5 minutes. With many offers per product (100+), raise the timeout in run options.
- Memory is fixed at 2 GB (a real Chrome browser is used).

### API, export and integrations

- **API:** start a run with the input JSON above and read the dataset items ([Apify API docs](https://docs.apify.com/api/v2)). The `All offers` view returns one row per shop offer.
- **Export:** JSON, CSV, Excel, XML or HTML from the Output tab or the dataset API.
- **Scheduling:** create a [schedule](https://docs.apify.com/platform/schedules) in Apify Console to collect prices every day.
- **Webhooks / no-code:** use an [Apify webhook](https://docs.apify.com/platform/integrations/webhooks) or the Make, Zapier or n8n integrations to send new rows to your sheet or database.

#### Use with AI agents (MCP)

See the [Apify MCP server docs](https://docs.apify.com/platform/integrations/mcp).

- MCP server URL with only this Actor: `https://mcp.apify.com?tools=cliqtomedia/idealo-price-scraper`
- Smallest useful input: `{"mode": "search", "queries": ["airpods pro"], "domain": "de", "maxItems": 10}`
- Key output fields: `title` (product), `bestPrice` (lowest item price), `offers[].shop` (shop name), `offers[].totalPrice` (price with shipping, null if not stated), `status` (`complete`, `partial`, `not_found`, `error`).
- The prefill run takes about 30 seconds and costs about $0.07. Limits: 200 products, 200 offers per product, 6 idealo sites.

### Troubleshooting

#### The run saved 0 products for my search

Symptom: the dataset is empty and `RUN_SUMMARY.queriesWithoutResults` lists your query.
Likely reason: idealo found no product comparison pages. For very specific words idealo often shows only single-shop offers; the summary then has a warning about it.
Check: search the same words on the idealo site in your browser.
Action: use a shorter, more general query, or paste the product URL in products mode.

#### A product has `bestPrice: null` and no offers

Symptom: `status: complete`, `offerCount: 0`.
Likely reason: idealo lists no new offers for this product now (often only used ones, which idealo shows separately).
Action: nothing is wrong with the run; check again later.

#### `shipping` and `totalPrice` are null for some offers

Symptom: `price` is set, `shipping` is null.
Likely reason: the shop does not state the shipping cost on idealo (for example "Spese di spedizioni addizionali, vedi negozio").
Action: open `offers[].url` to see the cost in the shop.

#### The run failed with a source error

Symptom: run status Failed, `RUN_SUMMARY.stopReason: SOURCE_ERROR`.
Likely reason: idealo blocked the requests, did not answer within 20 seconds (including retries), or its product pages changed so they could not be read.
Check: the rows saved before the error are still in the dataset.
Action: run again later, or turn on Apify Proxy (automatic group) in **Proxy**.

#### The run stopped with TIMEOUT

Symptom: fewer products than `maxItems`, `stopReason: TIMEOUT`.
Action: raise the timeout in run options, or lower `maxItems` or `maxOffersPerProduct`.

### FAQ

#### Do I need an idealo account or an API key?

No. The Actor reads the public idealo pages. No login, no API key.

#### Is the output the same as other idealo scrapers?

The prices, shops and product IDs are the same as on idealo, but field names are different (for example `title`, `gtin` and a nested `offers` list). If you move from another Actor, map the fields once.

#### Why is `offerCount` bigger than the number of offers I got?

You get up to `maxOffersPerProduct` offers (default 20). Set a bigger number to get more; each further 20 offers is one extra offer page event.

#### Are the prices live?

Yes, they are read at run time. `fetchedAt` shows when. idealo and shops can change prices at any time.

#### Why are the rows not in the same order as my URLs?

In products mode the Actor reads all products of one idealo site, then the next site. This keeps the run fast and cheap. Use `input` to match rows with your list.

#### Is this an official idealo tool?

No. This Actor is not affiliated with or endorsed by idealo internet GmbH. It reads public pages of [idealo](https://www.idealo.de). Check that your use of the data follows idealo's terms and the laws that apply to you.

### Support

For a bug, a question or a feature request, open an issue in the **Issues** tab of this Actor. Include the run ID, your input (queries or product URLs) and the `error` or `RUN_SUMMARY` text. Never send tokens, cookies or billing data.

# Changelog

This Actor's version history is a separate document: https://apify.com/cliqtomedia/idealo-price-scraper/changelog.md

# Actor input Schema

## `mode` (type: `string`):

Search: find products by keyword on the chosen idealo site. Products: read the idealo product pages you paste below.

## `queries` (type: `array`):

Keywords as you would type them on idealo, e.g. "airpods pro" or "samsung galaxy s25". Up to 20 queries; products from the first results page of each query are returned in idealo's order. Used when "What to scrape" is Search.

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

idealo product comparison pages from any supported country, e.g. https://www.idealo.de/preisvergleich/OffersOfProduct/207671730\_-airpods-pro-3-apple.html or https://www.idealo.fr/prix/207671730/apple-airpods-pro-3.html, or bare numeric product IDs (read on the site chosen below). Up to 200. Used when "What to scrape" is Products.

## `domain` (type: `string`):

Country site for searches and for bare product IDs. Product URLs always use their own site. Each country site opened in a run is one country-site event.

## `maxItems` (type: `integer`):

Most products to return in this run (1–200). Each returned product is one product event; a product ID that idealo does not have is a cheaper not-found event; invalid entries are free. Empty: 10 for searches, all pasted products in Products mode.

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

Shop offers to return per product, cheapest first in idealo's default order (0–200). 20 offers come with the product page; more are loaded 20 at a time, which takes a little longer and is charged as one extra offer page per 20 offers. 0 returns product data and best price only.

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

Not needed in most cases. Turn on Apify Proxy only if runs report that idealo blocked the requests.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "airpods pro"
  ],
  "domain": "de",
  "maxItems": 10,
  "maxOffersPerProduct": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `products` (type: `string`):

One row per product: best price, offer count, category, rating, status.

## `offers` (type: `string`):

One row per shop offer: shop, price, shipping, total, delivery.

## `runSummary` (type: `string`):

Status, stop reason, counts and queries without results.

# 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 = {
    "mode": "search",
    "queries": [
        "airpods pro"
    ],
    "domain": "de",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("cliqtomedia/idealo-price-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 = {
    "mode": "search",
    "queries": ["airpods pro"],
    "domain": "de",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("cliqtomedia/idealo-price-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 '{
  "mode": "search",
  "queries": [
    "airpods pro"
  ],
  "domain": "de",
  "maxItems": 10
}' |
apify call cliqtomedia/idealo-price-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cliqtomedia/idealo-price-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/fj0XIVkc6BM8lGLMH/builds/02ilxGkL96e4LVbWN/openapi.json