# IKEA Scraper \[$0.70/1K💰] | Prices | Reviews | 50+ Markets (`ahmed_jasarevic/ikea-scraper`) Actor

Extract IKEA product prices, discounts, stock status and customer reviews across 50+ country markets. One API call returns up to 1,000 structured products with no browser and no proxy. Built for price monitoring, catalog builds and market research.

- **URL**: https://apify.com/ahmed_jasarevic/ikea-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 products

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

## IKEA Scraper — Product Prices, Discounts & Customer Reviews Across 50+ Markets

Extract structured IKEA product and review data for **price monitoring, catalog builds and market research** — across 50+ country markets, with **no browser and no proxy required**.

One API call returns up to **1,000 fully-structured products**, including localised price, previous price, discount amount, stock status, category path, measurements, variants and images. Customer reviews and per-product rating summaries land in a second dataset.

**Measured:** 200 products from one search call in ~2 s; review batches of 200 at ~0.7 s per request, 10 concurrent. IKEA has no public developer API for catalog or review data, and `www.ikea.com` sits behind a Cloudflare wall that returns HTTP 403 to datacenter IPs — this Actor reads the two JSON microservices that feed IKEA's own storefront instead.

***

### Main use cases

- **IKEA price monitoring** — track price cuts, `NEW_LOWEST_PRICE` tags and discount windows across countries
- **Multi-market price comparison** — same SKU priced in GBP vs EUR vs PLN, with `sourceCountry` provenance on every row
- **Catalog and product-database builds** — full category trees plus every variant SKU with its own price, rating and image
- **Review and sentiment analysis** — customer review text, star ratings, per-topic sub-ratings and rating distributions
- **AR / configurator and room-planner pipelines** — measurements, colours, category path and image sets
- **Competitor assortment research** — how IKEA ranges a category in a given market versus another

***

### Which data sources are used, and why

#### Products — IKEA search microservice

```
GET https://sik.search.blue.cdtapps.com/{country}/{language}/search-result-page
        ?q={query}&size={1..1000}&types=PRODUCT
```

Example:

```
https://sik.search.blue.cdtapps.com/gb/en/search-result-page?q=sofa&size=200&types=PRODUCT
```

Only a normal desktop `User-Agent` and `Accept: application/json` are needed. **No cookies, no API key, no session token, no CSRF token.**

#### Reviews and ratings — IKEA ratings microservice

```
POST https://web-api.ikea.com/tugc/public/v5/reviews/{country}/{language}/{itemNo}
GET  https://web-api.ikea.com/tugc/public/v5/rating/{country}/{language}/{itemNo}
```

One static header authenticates both:

```
x-client-id: a1047798-0fc4-446e-9616-0afe3256d0d7
```

The review id comes from each product row's `itemNo` field.

#### Why these and not ikea.com

| Surface | Result |
|---|---|
| `www.ikea.com/{c}/{l}/p/{slug}-{itemNo}/` | **HTTP 403** — Cloudflare WAF blocks datacenter and residential IPs |
| Legacy `www.ikea.com/.../products/search/` JSON | **HTTP 403** — same wall |
| `__NEXT_DATA__` / `ld+json` / `dataLayer` blobs | Unreachable — the HTML is never served, so there is no blob to parse |
| **`sik.search.blue.cdtapps.com`** | **HTTP 200**, clean JSON, no auth — the exact endpoint the ikea.com frontend calls |
| **`web-api.ikea.com`** | **HTTP 200**, clean JSON, one static header — the exact endpoint the frontend calls |

Both microservices live on different hosts from `www.ikea.com` with their own edges, so they do not carry the storefront's WAF rules. This is the "find a structured source on a cheaper surface" bypass: the storefront blocks you, the backends that feed the storefront do not.

#### Why it is dramatically cheaper than a browser

- **Up to 1,000 products per request.** There is no `page`/`offset` parameter — `size` (max 1000) is the whole pagination mechanism.
- **No browser at all.** A run is plain JSON HTTP: `CheerioCrawler` over the search API, `HttpCrawler` over the review API. Zero rendering cost.

#### Validated API behaviour

- `size` must be **1–1000** (`> 1000` → `400 "Size parameter cannot exceed 1000"`).
- There is **no** `page`/`offset`/`start` parameter, and `moreToken` is not accepted over HTTP. Use a larger `size` or more queries.
- **Category keys work as queries** — e.g. `q=25219` returns the whole "Dining chairs" category. Category keys are published in every product's `categoryPath[].key`, so the whole tree is crawlable this way.
- IKEA category IDs are **market-specific** (`25219` is a GB category).
- Review pages accept up to **500**. IKEA pools some reviews at series level, so a product can return reviews for sibling variants; reviews are deduplicated globally by review id across the run.
- A product with no reviews returns `200` with an empty array; `rating` returns an empty array too.
- Errors arrive as `{"status": 400, "title": "Bad Request", "detail": "..."}` and are converted into Crawlee retries (3 attempts).

***

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `searchQueries` | array | no | `["chair"]` | Product keywords **or** category keys. One API call each. |
| `country` | string | no | `us` | IKEA market code: us, gb, de, fr, se, ch, ca, au, nl, pl, es, it, at, no, dk, fi, cz, pt, ie, jp, mx, br, in, zh, sg, my, tr. |
| `language` | string | no | `en` | Language segment for that market: en, de, fr, sv, nl, es… |
| `resultsPerQuery` | integer | no | `200` | Results per call. **API max 1000.** |
| `useSeedQueries` | boolean | no | `false` | Adds ~60 built-in seed queries (a–z letter pairs + furniture terms) for a broad catalog sweep. Adds one API call per seed. |
| `sortOrder` | string | no | `""` (API default) | `RELEVANCE`, `PRICE_LOW_TO_HIGH`, `PRICE_HIGH_TO_LOW`, `NEWEST`, `RATING`, `NAME_ASCENDING`, `MOST_POPULAR`, `WIDTH`, `HEIGHT`, `DEPTH`, `LENGTH`. |
| `includeVariants` | boolean | no | `true` | Include sibling colour/finish variant SKUs as their own rows. |
| `scrapeReviews` | boolean | no | `true` | Fetch reviews for every scraped product into the second dataset. Requires 1–2 extra API calls per product. |
| `reviewsPerProduct` | integer | no | `50` | Max reviews kept per product (1–100000). Above 500, requests paginate with `page.size=500`. |
| `reviewsSortBy` | string | no | `newest` | `newest`, `oldest`, `helpful`, `rating-desc`, `rating-asc`. |
| `includeRatingSummary` | boolean | no | `true` | One **free** `rating-summary` row per product with star distribution and sub-ratings. Only used when `scrapeReviews` is on. |
| `maxItems` | integer | no | `0` (uncapped) | Hard cap on product rows. |
| `maxRequestsPerCrawl` | integer | no | `1000` | Total API-call budget, shared by the product and review phases. |
| `proxy` | object | no | `useApifyProxy: false` | Standard Apify proxy picker. Not needed for normal volumes. |

***

### Output

Two flat JSON datasets. The product dataset offers an `overview` view and a `prices` price-history view.

#### Products dataset (default) — one row per product, plus one per variant when `includeVariants` is on

| Field | Description |
|---|---|
| `name`, `productName`, `productType`, `itemType` | e.g. `SANDSBERG` / `SANDSBERG Chair` |
| `itemNo`, `itemNoGlobal` | IKEA article number. **`itemNo` is the join key into the reviews dataset.** |
| `price`, `currency`, `priceFormatted` | Localised: `35` / `GBP` / `£35` |
| `previousPrice`, `previousPriceFormatted`, `previousPriceLabel` | e.g. `40` / `£40` / `"Previous price"` |
| `discountAmount`, `discountPercentage`, `discountText` | e.g. `5` / `12` / `-12%` |
| `priceTag`, `priceTagText` | `NONE`, `NEW_PRODUCT`, `FAMILY_PRICE`, `DISCONTINUED_PRODUCT` |
| `priceValidFrom`, `priceValidTo`, `availabilityDisclaimer` | Price-validity window — the fields price monitors key on |
| `advertisement[]` | IKEA Family / in-store-only offers |
| `ratingValue`, `ratingCount` | Average rating and review count |
| `colors[]`, `colorHex[]`, `selectedColor` | Colour options |
| `measurements.text`, `measurements.variants` | e.g. `40/35x38x7 cm` |
| `quickFacts[]`, `features[]` | Material and type chips |
| `numberOfVariants`, `variantGroups[]`, `variants[]` | Variant matrix + every sibling SKU with its own price, rating, image and URL |
| `mainImageUrl`, `mainImageAlt`, `contextualImageUrl`, `images[]` | All image types (`MAIN` / `CONTEXT` / `FUNCTIONAL` / `QUALITY`) |
| `categoryPath[]`, `categoryPathText`, `businessStructure`, `filterClass` | Full taxonomy, `A > B > C` |
| `onlineSellable`, `lastChance`, `availability[]`, `stockStatus` | `AVAILABLE` / `LAST_CHANCE` / `NOT_ONLINE_SELLABLE` |
| `sourceCountry`, `sourceLanguage`, `sourceQuery`, `scrapedAt` | Provenance — essential for multi-market comparison |

#### Reviews dataset (`reviews`, only when `scrapeReviews` is on)

Two row kinds, told apart by `rowType`:

- **`rowType: "review"`** — one row per customer review: `reviewId`, `reviewItemNo`, `title`, `text`, `ratingValue` + `secondaryRatings[]`, `isRecommended`, `verifiedPurchase`, `verifiedReviewer`, `anonymousReviewer`, feedback counts, `reviewerDisplayName`, `submissionOn` / `updatedOn`, `media[]`, `ikeaResponse`. Join keys (`itemNo`, `itemNoGlobal`, `productName`, `pipUrl`) are repeated on every review row. **Billed per review.**
- **`rowType: "rating-summary"`** — one row per product: overall `ratingValue`, `ratingDistribution[]` (per-star counts), `subRatings[]`, `totalRatingCount`, `totalRecommendedCount`, `firstReviewedOn` / `lastReviewedOn`. **Free.**

Filter on `rowType` client-side when you only want one kind.

***

### Example input

Price sweep across two markets:

```json
{
  "searchQueries": ["sofa", "desk"],
  "country": "gb",
  "language": "en",
  "resultsPerQuery": 500
}
```

Whole-category crawl using a market-specific category key, with variants and reviews off for speed:

```json
{
  "searchQueries": ["25219"],
  "country": "gb",
  "language": "en",
  "includeVariants": false,
  "scrapeReviews": false
}
```

Broad catalog sweep with reviews, deepest ratings first:

```json
{
  "useSeedQueries": true,
  "country": "us",
  "language": "en",
  "resultsPerQuery": 1000,
  "maxItems": 5000,
  "scrapeReviews": true,
  "reviewsPerProduct": 100,
  "reviewsSortBy": "rating-desc"
}
```

***

### Example output

Product row:

```json
{
  "name": "SANDSBERG",
  "productName": "SANDSBERG Chair",
  "itemNo": "605.286.98",
  "itemNoGlobal": "60528698",
  "price": 35,
  "currency": "GBP",
  "priceFormatted": "£35",
  "previousPrice": 40,
  "previousPriceFormatted": "£40",
  "discountAmount": 5,
  "discountPercentage": 12,
  "discountText": "-12%",
  "priceTag": "NONE",
  "ratingValue": 4.6,
  "ratingCount": 1284,
  "measurements": { "text": "40/35x38x7 cm", "variants": [] },
  "categoryPathText": "Home office furniture > Office chairs > Desk chairs",
  "stockStatus": "AVAILABLE",
  "onlineSellable": true,
  "numberOfVariants": 4,
  "sourceCountry": "gb",
  "sourceLanguage": "en",
  "sourceQuery": "25219",
  "scrapedAt": "2026-09-29T10:00:00.000Z"
}
```

Review row:

```json
{
  "rowType": "review",
  "reviewId": 7712345678,
  "reviewItemNo": "605.286.98",
  "itemNo": "605.286.98",
  "productName": "SANDSBERG Chair",
  "title": "Great value",
  "text": "Sturdy and comfortable for the price. Assembly took about ten minutes.",
  "ratingValue": 5,
  "isRecommended": true,
  "verifiedPurchase": true,
  "reviewerDisplayName": "M. K.",
  "submissionOn": "2026-08-14",
  "scrapedAt": "2026-09-29T10:00:01.000Z"
}
```

***

### Build IKEA price monitors and product databases on a schedule

Every Apify Actor is callable over HTTP, so the natural setup is a recurring run against the same query set, diffed into your own store:

- **Daily** — same `searchQueries` + `country`; diff `price`, `previousPrice`, `priceTag` and `priceValidFrom` to catch cuts and new-lowest-price flags
- **Weekly** — rotate countries to build a cross-market price index for the same article numbers
- **On demand** — call the Actor straight from your backend via the Apify API and read the dataset as JSON, CSV or Excel
- **Connect the tools you already use** — Apify webhooks, Zapier, Make, Google Sheets and 100+ integrations fire on run completion

Run it on `latest`, pin a build number, or trigger it from your own scheduler. The `prices` dataset view is a ready-made price-history table with valid-from / valid-to dates.

***

### Related Actors

- [Ikea Scraper](https://apify.com/crawlerbros/ikea-scraper) (`crawlerbros/ikea-scraper`) — multi-country IKEA storefront scraper with per-product and per-category modes
- [IKEA Product Search Scraper](https://apify.com/cirkit/ikea-product-search-scraper) (`cirkit/ikea-product-search-scraper`) — IKEA catalog search with optional per-store stock enrichment
- [IKEA Reviews Scraper](https://apify.com/shahidirfan/IKEA-Reviews-Scraper) (`shahidirfan/IKEA-Reviews-Scraper`) — dedicated review-only run for large-scale review collection
- [Amazon Bestsellers Scraper](https://apify.com/ahmed_jasarevic/amazon-bestsellers-scraper) — the same price-monitoring and ranking workflow on Amazon
- [Idealo Scraper](https://apify.com/ahmed_jasarevic/idealo-scraper) — German price-comparison history across 6 markets, pairs well for EU assortment studies

***

### FAQ

#### Why not use an official IKEA API instead?

IKEA publishes no public developer API for catalog, pricing or review data. The only documented services are internal *IKEA Knowledge Graph* endpoints (`knowledge.api.inter.ikea.net`), which cover product add-ons and range recommendations — not search, prices or reviews. Every third-party "IKEA API" is a wrapper around the same public JSON microservices this Actor reads directly, so you can skip the subscription layer.

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

- Browser-based IKEA scrapers — work, but roughly 50× the cost per run for the same JSON, and they still have to defeat Cloudflare.
- Managed third-party APIs (RapidAPI listings, data-API vendors) — add a subscription, a per-call price and a vendor dependency between you and the same source.
- The archived `ikea_api` Python client — requires generating a guest token through ikea.com cookies and expires every 30 days.

#### How do I scrape a whole IKEA category?

Read any product's `categoryPath[]` entries — each has a `key` — then pass that key as a `searchQueries` value (`q=25219` returns the entire "Dining chairs" category in one call). Category IDs are market-specific, so resolve them from a product in the same country you are crawling. For the broadest sweep in one run, set `useSeedQueries: true`.

#### Can I get more than 1,000 products in one run?

Yes. `resultsPerQuery` caps a single call at 1,000, but the run continues across multiple queries and across `useSeedQueries` seeds. Use `maxItems` to cap total product rows and `maxRequestsPerCrawl` to cap total API calls.

#### Why are my reviews fewer than the rating count shows?

IKEA pools some reviews at *series* level, so reviews are deduplicated globally by review id across the whole run — two products in the same series share their pool. `reviewsPerProduct` also caps what is kept per product, and `includeRatingSummary` gives you the true per-product distribution for free.

#### Do I need a proxy, cookies or an API key?

No. The search and review microservices are read from any IP with a desktop User-Agent, and the review API authenticates with a single static public header. `proxy` defaults to `useApifyProxy: false` — enable it only if you specifically need a particular country exit.

#### How much does it cost?

Products are billed at **$0.0007–$0.00075 per row** depending on your plan tier, so roughly **$0.70–$0.75 per 1,000 products**; each review is billed as its own event and rating summaries are free. Product rows are dominated by plain JSON HTTP, not compute. Free Apify accounts are capped at 10 products per run; paying accounts are uncapped within `maxItems` / `maxRequestsPerCrawl`.

***

### For AI Agents & LLM Apps

Callable via the Apify MCP server and the Apify API. Returns IKEA products (default dataset) and, when enabled, customer reviews plus per-product rating summaries (second dataset).

**Minimal valid input** — one call returns up to 1,000 products:

```json
{ "searchQueries": ["chair"] }
```

**Category crawl** (category keys resolve to whole categories, market-specific):

```json
{ "searchQueries": ["25219"], "country": "gb", "language": "en" }
```

**Multi-market price comparison** — run the same query in several markets; `sourceCountry` / `sourceLanguage` on every row tell you which shop each price came from:

```json
{ "searchQueries": ["sofa"], "country": "de", "language": "de", "resultsPerQuery": 500 }
```

**Products only, cheapest run** — `scrapeReviews: false` removes all review events from the bill:

```json
{ "searchQueries": ["desk"], "scrapeReviews": false, "includeVariants": false }
```

**Output fields** — products: `name`, `productName`, `productType`, `itemNo`, `itemNoGlobal`, `price`, `currency`, `priceFormatted`, `previousPrice`, `previousPriceFormatted`, `discountAmount`, `discountPercentage`, `discountText`, `priceTag`, `priceTagText`, `priceValidFrom`, `priceValidTo`, `ratingValue`, `ratingCount`, `colors`, `colorHex`, `measurements`, `features`, `numberOfVariants`, `variantGroups`, `variants`, `mainImageUrl`, `images`, `categoryPath`, `categoryPathText`, `onlineSellable`, `lastChance`, `stockStatus`, `sourceCountry`, `sourceLanguage`, `sourceQuery`, `scrapedAt`. Reviews dataset: `rowType`, `reviewId`, `reviewItemNo`, `itemNo`, `productName`, `title`, `text`, `ratingValue`, `isRecommended`, `verifiedPurchase`, `reviewerDisplayName`, `submissionOn`, plus `rating-summary` rows carrying `ratingDistribution` and `subRatings`.

**Behaviors an agent should know**

- **`itemNo` is the join key** between the products dataset and the reviews dataset. Reviews cannot be requested without first discovering products.
- **There is no page/offset input.** `resultsPerQuery` (max 1000) is the only pagination mechanism; `searchQueries` and `useSeedQueries` are how you go wider. Do not invent an `offset` field.
- **`scrapeReviews` defaults to `true`.** If you want a catalog-only run, you must set it to `false` explicitly — otherwise every product triggers 1–2 extra billed API calls.
- **`useSeedQueries: true` adds roughly 60 additional API calls** on top of your queries. Budget `maxRequestsPerCrawl` accordingly; it defaults to 1000 and is shared across the product and review phases.
- **Reviews are deduplicated by review id across the entire run**, so `ratingCount` on a product and the number of review rows for it will not match. Use `rowType: "rating-summary"` rows for the true per-product distribution — those rows are free.
- **`categoryPath[].key` values are market-specific.** A key scraped from the GB shop will not return the same category on the DE shop. Resolve keys per country.
- **`variants[]` embeds sibling SKUs**; with `includeVariants: true` (default) those siblings can also appear as their own top-level rows. Deduplicate on `itemNo`.
- **Free accounts are capped at 10 products per run** regardless of `maxItems`.

**Billing model** — pay per event: one `Products` event per product row ($0.0007–$0.00075), one `Review` event per review row, and rating-summary rows are free. The Actor stops fetching reviews as soon as the run's billing limit is reached rather than overrunning the budget.

***

### Legal & Compliance Disclaimer

This Actor is an independent third-party tool. It is not affiliated with, endorsed by, sponsored by, or connected to IKEA, Ingka Group, or any of their brands.

It reads **only publicly available JSON API responses** from two microservices (`sik.search.blue.cdtapps.com` and `web-api.ikea.com`). It does not log in, does not bypass authentication, does not solve CAPTCHAs, does not use residential proxies by default, and does not collect any personal data about individuals. Extracted review text contains reviewer display names that IKEA itself publishes publicly — treat those as personal data and avoid sending unsolicited commercial outreach to them, as that can violate applicable law including GDPR, UK GDPR, CCPA, CAN-SPAM and TCPA.

You are responsible for your own compliance with IKEA's Terms of Service and with the data-protection law that applies to you. This Actor is a data-collection tool; it does not provide legal advice and makes no claim that any particular use is permitted.

***

### SEO Keywords

ikea scraper, ikea api, ikea product data, ikea price monitoring, ikea price tracker, ikea catalog data, furniture price monitoring, ikea reviews scraper, ikea product database, ikea stock data, ikea variant data, ikea category scraper, ikea api alternative, ikea dataset, multi-country ikea pricing, ikea market research, ecommerce price monitoring, furniture catalog database, product review scraper, competitor assortment analysis, drop shipping furniture data, ikea bulk product data

# Actor input Schema

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

Product keywords to search for, e.g. \["desk", "chair", "poaeng"]. Each query returns up to `resultsPerQuery` products in a single API call. Category keys (e.g. 25219 for Dining chairs) also work as queries.

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

IKEA country market code, e.g. us, gb, de, fr, se, ch, ca, au, nl, pl, es, it, at, no, dk, fi, cz, pt, ie, jp, mx, br, in, zh, sg, my, tr.

## `language` (type: `string`):

IKEA language segment for the chosen country, e.g. en, de, fr, sv, nl, es.

## `resultsPerQuery` (type: `integer`):

How many products to pull per query. The API caps this at 1000, so one call can return an entire result set.

## `useSeedQueries` (type: `boolean`):

When true, the actor also runs a built-in seed query list (a-z letter pairs + common furniture terms) to enumerate a much broader slice of the country catalog. Adds one API call per seed query.

## `sortOrder` (type: `string`):

Optional sort order passed to the IKEA search API. Leave empty for the API default (relevance).

## `includeVariants` (type: `boolean`):

Include the variant (sibling colour/finish) sub-objects of each product series.

## `scrapeReviews` (type: `boolean`):

When true, also collect customer reviews for every product that was scraped and write them to a second dataset called `reviews`. Requires 1-2 extra API calls per product. Reviews are billed per event; the per-product rating summary is free.

## `reviewsPerProduct` (type: `integer`):

Maximum reviews to collect per product. The reviews API returns up to 500 per call, so values above 500 use extra page requests. Only used when `scrapeReviews` is true.

## `reviewsSortBy` (type: `string`):

Order in which reviews are collected. Useful controls the newest reviews come first, or the most/least helpful.

## `includeRatingSummary` (type: `boolean`):

Also fetch each product's rating aggregate: star distribution, per-topic sub-ratings (quality, ease of assembly, value for money, ...), recommendation counts and first/last review dates. Written to the `reviews` dataset as a `rating-summary` row and never billed. Only used when `scrapeReviews` is true.

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

Hard cap on the number of products written to the dataset. 0 = no cap beyond the request cap.

## `maxRequestsPerCrawl` (type: `integer`):

Hard cap on how many IKEA API calls this run may make in total, across both the product search and the review phase.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "searchQueries": [
    "chair"
  ],
  "country": "us",
  "language": "en",
  "resultsPerQuery": 200,
  "useSeedQueries": false,
  "sortOrder": "",
  "includeVariants": true,
  "scrapeReviews": true,
  "reviewsPerProduct": 50,
  "reviewsSortBy": "newest",
  "includeRatingSummary": true,
  "maxItems": 0,
  "maxRequestsPerCrawl": 1000,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per unique product: name, item number, localised price, previous price and discount, rating, colours, measurements, variants, images, category path and stock status.

## `priceChanges` (type: `string`):

The same products as the 'products' output, shown as a price history table with valid-from and valid-to dates.

## `reviews` (type: `string`):

Empty unless `scrapeReviews` is enabled. One row per customer review, each of which is charged as an `ikea-review` pay-per-event. Rows with `rowType: rating-summary` are free and hold the product's rating distribution and sub-ratings.

# 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 = {
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/ikea-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 = { "proxy": { "useApifyProxy": False } }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/ikea-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 '{
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/ikea-scraper --silent --output-dataset

```

## MCP server setup

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