# IKEA Product Search Scraper (`automation-lab/ikea-product-search-scraper`) Actor

Export US English IKEA keyword search products with item numbers, names, product types, advertised prices, currency, product links and images for assortment and price snapshots.

- **URL**: https://apify.com/automation-lab/ikea-product-search-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.82 / 1,000 product exporteds

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 Product Search Scraper

Export **IKEA product search** results for US furniture assortment and advertised-price snapshots. Enter a keyword such as `billy`, `desk` or `chair` and receive structured product records with item numbers, names, types, prices, currency and product/image links.

This independent tool is not affiliated with IKEA. It searches US English only. It does not check store stock, scrape reviews, or perform product-page enrichment.

### Who is this for?

- Retail analysts maintaining comparable furniture assortments.
- Interior-design researchers collecting source-linked candidate products.
- Data teams saving periodic search snapshots in spreadsheets or warehouses.

### Why use this Actor?

Get a small, predictable catalog export without downloading product images or opening a browser. Stable item numbers make downstream joins easier, while query, market and timestamps explain each snapshot's context. Search products are deduplicated within each run.

### Getting started

1. Open the Input tab.
2. Enter one search query, for example `billy`.
3. Choose a maximum number of products.
4. Run the Actor.
5. Inspect Products in the Output tab or export the dataset as JSON, CSV or Excel.

```json
{"query":"billy","maxItems":100}
```

### Inputs and matching semantics

| Field | Behavior |
| --- | --- |
| `query` | Required string, 1–200 characters after trimming. Submitted to IKEA search. |
| `maxItems` | Integer 1–1000; default 100. Global limit of unique main search products saved in this run. |

IKEA controls relevance, ranking, spelling correction and related matches. A phrase is not an exact whole-field, substring or whole-word filter. Review the returned names and types for your analysis. Whitespace at the ends is removed; query case is otherwise passed through.

Only these two fields are accepted. Country/language selection, URL inputs, multiple-query arrays and custom proxies are unsupported. Unknown fields fail validation rather than silently being ignored.

### Coverage and result limits

The Actor requests a bounded window of at most 1000 ranked main products from the anonymous catalog JSON endpoint in one request. It does not paginate beyond that window or promise the entire IKEA catalog. A single source request can supply the whole supported window, avoiding repeated downloads of growing prefixes.

Duplicate item numbers are removed without fetching replacements. Additional color/size variants nested under a main search product are not expanded. Products that appear as separate main results remain eligible. Search result totals may change between runs.

`maxItems: 0` does not mean unlimited; it is rejected. Source exhaustion can produce fewer than the requested number. A genuinely unmatched query completes with an empty dataset and a summary showing zero available matches.

### Extracted fields

| Field | Meaning |
| --- | --- |
| `itemNumber` | Source item or combination identifier, stored as text. |
| `name` | Product family name. |
| `productType` | Source product type; null if unavailable. |
| `price` | Advertised numeric catalog price; null if absent. |
| `currency` | Source currency code; null if absent. |
| `productUrl` | US English IKEA product page. |
| `imageUrl` | Main image link; null if absent. Image file is not downloaded. |
| `query` | Trimmed submitted query. |
| `market` | Always `us/en`. |
| `scrapedAt` | UTC extraction timestamp. |

Prices are snapshots, not checkout quotes. Taxes, delivery, member eligibility, promotions and availability may differ at purchase time. There is no stock guarantee or historical price database.

### Output example

A representative source product from the `billy` search:

```json
{
  "itemNumber":"20522046",
  "name":"BILLY",
  "productType":"Bookcase",
  "price":79,
  "currency":"USD",
  "productUrl":"https://www.ikea.com/us/en/p/billy-bookcase-white-20522046/",
  "imageUrl":"https://www.ikea.com/us/en/images/products/billy-bookcase-white__1590272_pe1038911_s5.jpg",
  "query":"billy",
  "market":"us/en",
  "scrapedAt":"2026-10-25T07:00:00.000Z"
}
```

The `SUMMARY` key-value record reports actually persisted products (`saved`), source total, request attempts, market and whether output is truncated relative to the source total. `billingLimited` is true when the SDK saves fewer products than the attempted batch because of the remaining billing allowance. No uncharged replacement products are written. The summary is not separately charged.

Platform billing or runtime limits can reduce the requested window, including to zero products. A terminated run may have only partial output and no final summary; check its status and dataset rather than assuming `maxItems` were saved.

### How much does it cost to export IKEA search products?

Pay-per-event pricing consists of a **$0.0005 start fee** plus a charge for each saved product. The start fee also applies to valid searches with no matches. Invalid input is rejected before this fee. Failed requests and duplicate products do not incur product-event charges.

| Apify spending tier | Per product |
| --- | ---: |
| FREE | $0.001564 |
| BRONZE | $0.00136 |
| SILVER | $0.0010608 |
| GOLD / PLATINUM / DIAMOND | $0.000816 |

At BRONZE, 10 products cost 0.0141 USD and 100 cost 0.1365 USD, including the start event. These are Actor event-charge examples, not claims about unrelated platform subscriptions or third-party services. Platform billing remains authoritative.

### Integrations and repeated snapshots

Use Apify schedules to run the same query periodically, then send datasets to Google Sheets, a database or your ETL pipeline through Apify integrations, webhooks or the API. Join snapshots on `itemNumber` and `market`, retain `scrapedAt`, and compare prices downstream.

The Actor does not calculate diffs, send alerts, remember previous runs or guarantee historical completeness. Keep separate snapshots yourself. Search ordering and assortment can change, so a missing record does not establish a discontinued product.

### API usage

Start once with your Apify token stored securely in an environment variable:

```bash
curl -X POST \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"query":"billy","maxItems":100}' \
  'https://api.apify.com/v2/acts/automation-lab~ikea-product-search-scraper/runs'
```

JavaScript with `apify-client`:

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ikea-product-search-scraper')
  .call({ query: 'billy', maxItems: 100 });
if (run.status !== 'SUCCEEDED') throw new Error(run.status);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 100 });
console.log(items);
```

Python with `apify-client`:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/ikea-product-search-scraper').call(
    run_input={'query': 'billy', 'maxItems': 100})
if run['status'] != 'SUCCEEDED':
    raise RuntimeError(run['status'])
print(client.dataset(run['defaultDatasetId']).list_items(limit=100).items)
```

### MCP usage

Configure a stable Actor-specific subset:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/ikea-product-search-scraper'
```

For Claude Desktop, Cursor and VS Code clients using JSON configuration:

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/ikea-product-search-scraper"}}}
```

Authenticate through your client's supported Apify authorization flow. Discover actual tool names and arguments using scoped `tools/list`. Actor selection also adds run and storage helpers; it is not exactly one tool.

Example prompts for MCP usage: “Search IKEA US English for billy, maximum 20 products, then show item numbers, names and advertised prices.”

For an authorized invocation, start once and retain the returned run ID and storage IDs. IDs are metadata, not result rows. `call-actor` waits at most 45 seconds; if nonterminal, check that same run with `get-actor-run`, using bounded 2/4/8-second backoff capped at 10 seconds and a 120-second total deadline. On timeout, recover the known run instead of restarting it; report pending at the deadline. Failed-run rows are partial, not a complete successful export.

After success, use `get-dataset-items` with explicit offset, limit and fields. A practical consumer budget is pages of 20 source rows, at most 100 rows and 64 KiB of serialized UTF-8 content admitted to model context, whichever comes first. Enforce byte limits host-side before model injection; if your client cannot intercept oversized responses, do not claim a hard byte bound. Track source offsets, disclose omitted/partial rows and give a continuation offset. Keep full exports outside model context.

### Failures and troubleshooting

Transient network errors, HTTP 429 and 5xx receive at most three total attempts with bounded backoff. Other HTTP errors, non-JSON content and incompatible response structures fail the run; a blocked response is never reported as a successful empty search. No automatic paid proxy fallback is enabled.

If a run fails after writing products, those rows are partial. Check the log and run status before consuming them as a complete snapshot. Validation problems require correcting the input, not rerunning unchanged data.

### Legality and privacy

Use the public catalog responsibly and comply with applicable laws, website terms and intellectual-property rights. Product images remain linked to their source and are not downloaded. This tool does not grant rights to republish IKEA content.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed; reports are retained for 30 days. Avoid putting confidential information in search terms. Runtime extraction uses no AI models or paid third-party data providers. Dataset and log retention follow your Apify storage settings; delete run storage when no longer needed. For help, use the Actor's Apify Issues tab.

### FAQ

**Can I check a specific store's stock?** No. This is keyword catalog discovery, not an availability service.

**Why did a related product appear?** IKEA determines relevance and can return related matches. There is no additional exact-name filter.

**Can I select another market?** No. Only US English is implemented and tested.

**Does the Actor compare prices automatically?** No. Schedule repeated runs and compare saved snapshots downstream.

**Why are fewer than maxItems returned?** The source may have fewer matches or duplicate main products; platform billing/runtime limits can also reduce output. Check `SUMMARY.billingLimited` and run status. No variant expansion or replacement fetch is performed.

### Related workflows

For broader comparison, use other source-specific Actors from [automation-lab](https://apify.com/automation-lab). This Actor deliberately stands alone: other retailers have different identifiers, prices and fulfillment terms, so their coverage is not combined here.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/ikea-product-search-scraper/changelog.md

# Actor input Schema

## `query` (type: `string`):

One IKEA search term or phrase, trimmed before submission. IKEA controls relevance, spelling correction and related matches; this is not exact phrase matching. US English only.

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

Global run limit of unique ranked main search products, from 1 to 1000; default 100. Zero and unlimited are unsupported. The API is asked for this bounded window in one request; duplicates are removed without fetching replacements. Variants not listed as main results are excluded. Fewer results may exist.

## Actor input object example

```json
{
  "query": "billy",
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Unique US English catalog products returned by IKEA search.

## `summary` (type: `string`):

Saved count, available total, request attempts and truncation status.

# 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 = {
    "query": "billy",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ikea-product-search-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 = {
    "query": "billy",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ikea-product-search-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 '{
  "query": "billy",
  "maxItems": 10
}' |
apify call automation-lab/ikea-product-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/ikea-product-search-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/awgxBK3CQn7gAqIUn/builds/zy0a6BF3vW4o4MkQZ/openapi.json