# Dunnes Stores Scraper — Fashion & Home Prices, Sizes, EANs (`architekture/dunnes-ie-scraper`) Actor

Scrape Dunnes Stores Ireland fashion and home: EUR prices, sale prices, every size with EAN and availability, categories, care and fit. Not groceries. Pay per result.

- **URL**: https://apify.com/architekture/dunnes-ie-scraper.md
- **Developed by:** [architek.earth](https://apify.com/architekture) (community)
- **Categories:** AI, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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

## Dunnes Stores Scraper — Fashion & Home Prices, Sizes, EANs

**Recorded 18 Oct 2026 from Apify datacenter IPs, no proxy: dunnesstores.com lists 4,980 fashion and home products. A "jeans" search listed 59 products and Home › Bedroom listed 219. Every row came with EUR prices, every size and colour with its EAN barcode and availability, and the full category path. A 15-request burst was never blocked.**

From **Architekture**, makers of the ALDI Ireland, Tesco UK, Shopify and AliExpress scrapers.

Search dunnesstores.com by keyword, browse a department or category, or look up product URLs. You get one clean JSON row per product, with every size and colour nested inside: name, brand, style code, price range, sale prices, availability per size, EAN per size, category path, gender and age group, image and URL. Turn on details to add the description, details and care (composition and washing), size and fit (measurements), country of origin, and every image.

> **Fashion & home only, not groceries.** Dunnes sells groceries on a separate site, which this actor does not cover. It covers dunnesstores.com: Women, Men, Kids, Home, Seasonal and School.

🤖 **Built for AI workflows.** Every row is deterministic, schema-stable JSON — feed it straight to LLM apps, RAG pipelines, or agent tool calls via the Apify API, the Apify MCP server (`mcp.apify.com`), or AI coding agents like Claude Code and Cursor.
| 🏪 Retailer | 📍 Market | 💰 From | 🔑 Standout fields |
|---|---|---|---|
| Dunnes Stores | Ireland 🇮🇪 | $1.00 / 1,000 products | All sizes & colours in one row, details & care |

### 🚀 Why choose this actor

- 🔬 **One row per product, all sizes inside.** You pay per product, not per size: a pair of jeans in 18 sizes is one `product` row with `variants[18]`.
- 🔬 **EAN barcode on every size.** Use it to match Dunnes products against other retailers, or against your own catalogue.
- 💸 **Sale detection per size.** Dunnes discounts individual sizes or colours (e.g. a duvet cover, ivory double, at €5, was €25). Each discounted variant carries `wasPrice`. The product's `price`, `maxPrice` and `onSale` are worked out from the sizes in stock, so a sold-out €5 size never shows as "from €5".
- 💸 **Detail tier you only pay for when it's there.** With `includeDetails`, a row is charged as `product-detail` only when Dunnes published a description, care, fit or origin for it. Extra images alone don't trigger the detail price.
- 🆓 **Never pay for misses.** An unknown category, a missing product or a blocked request gets one free status row.

### ⚠️ Worth knowing up front

- 📊 **No stock counts.** Dunnes' API publishes a capped stock indicator, not a quantity. You get `available: true/false` per size, and we never estimate a count.
- 🔎 **Up to 2,500 products per search term or category.** That's the limit of Dunnes' API. A department bigger than that is reachable by listing its sub-categories, and `RUN_SUMMARY` warns when a query hits the limit.
- 💸 **Prices are the online prices shown on dunnesstores.com, in EUR.** Store-only promotions are not included.
- 🗂️ **No reviews.** Dunnes does not publish them in its catalogue.

### ⚡ Try the example

```json
{
  "searchTerms": ["jeans"],
  "maxItemsPerQuery": 50
}
```

Add `"includeDetails": true` for composition, care and size-fit, or `"categories": ["home/bedroom"]` for a whole category.

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | array | — | Keywords, e.g. `jeans`, `duvet cover`. Up to 50 terms + categories. |
| `categories` | array | — | Name (`Home`, `Duvet Covers`), path (`women/clothing/jeans`) or dunnesstores.com category URL. An ambiguous name like `Clothing` (Women and Men both have one) needs the path. |
| `productUrls` | array | — | dunnesstores.com product URLs (`…/savida-stripe-jeans-7951169/p`) or product ids (`36256`). Up to 500. |
| `maxItemsPerQuery` | integer | `100` | Cap per search term or category. `0` = everything (up to 2,500). |
| `includeDetails` | boolean | `false` | Adds the detail tier (see below). Needs no extra requests, so it doesn't slow the run. |
| `sort` | select | `relevance` | `relevance`, `price_asc`, `price_desc`, `newest`, `best_selling`, `name_asc`, `name_desc`. |
| `proxyConfiguration` | proxy | Apify datacenter | Blocked or rate-limited requests are retried on a fresh IP. |
| `feedback` | string | — | A note to the maintainers. Read by a human. |

Results are de-duplicated by product across every term, category and URL in a run, so a product found twice is delivered and charged once. Product URLs are fetched first.

### 🧱 Stable fields for automations

Product rows have `recordType: "product"`; status rows have `recordType: "query"`. Fields are **omitted, never `null`**, when Dunnes does not publish them. New fields are only ever added.

| Field | Meaning |
|---|---|
| `recordType`, `retailer` | `product`; `"Dunnes Stores"`. |
| `productId`, `styleCode` | Dunnes product id and style code (the number in the product URL). |
| `name`, `brand` | e.g. `"Savida Stripe Jeans"`, `"Savida"`. Brands seen include Savida, Gallery and Dunnes Stores. |
| `department`, `category`, `categoryPath` | `"Women"`, `"Jeans"`, `"Women > Clothing > Jeans"`. |
| `price`, `maxPrice`, `currency` | Lowest and highest price among in-stock sizes (all sizes if none is in stock), `"EUR"`. |
| `onSale`, `available` | An in-stock size is discounted (any size if none is in stock); any size in stock. |
| `colours`, `gender`, `ageGroup` | As tagged by Dunnes. |
| `variantCount`, `variants[]` | Each variant: `sku`, `ean`, `size`, `colour`, `price`, `wasPrice` (only when discounted), `available`. |
| `image`, `url`, `releaseDate` | Main image, product page, date Dunnes listed it. |
| `source` | `{source: "search" \| "category" \| "product", searchTerm?, category?, categoryUrl?, page?}`. |
| Detail tier: `description`, `detailsAndCare`, `sizeFit`, `countryOfOrigin`, `images` | With `includeDetails`, where published. `detailsAndCare` and `sizeFit` are plain text with one item per line. |
| Status rows: `query`, `status`, `reason` | `NOT_FOUND`, `BLOCKED` or `ERROR`, and why. |

### 📦 Output example

Recorded 18 Oct 2026; variants abridged.

```json
{
  "recordType": "product",
  "retailer": "Dunnes Stores",
  "productId": "36256",
  "styleCode": "7951169",
  "name": "Savida Stripe Jeans",
  "brand": "Savida",
  "department": "Women",
  "category": "Jeans",
  "categoryPath": "Women > Clothing > Jeans",
  "price": 50.0,
  "currency": "EUR",
  "onSale": false,
  "available": true,
  "colours": ["Print"],
  "gender": "female",
  "ageGroup": "adult",
  "variantCount": 7,
  "variants": [
    { "sku": "265134", "ean": "5099013076909", "size": "10", "colour": "Stripe", "price": 50.0, "available": true },
    { "sku": "265137", "ean": "5099013076985", "size": "16", "colour": "Stripe", "price": 50.0, "available": false }
  ],
  "url": "https://www.dunnesstores.com/savida-stripe-jeans-7951169/p",
  "source": { "source": "search", "searchTerm": "jeans", "page": 1 }
}
```

With details on, a bedding row also carries text like `"detailsAndCare": "Details:\n100% polyester\nCare:\nWash at 40 degrees\n…"`, `"sizeFit": "Single: 90 x 190cm + 28cm\n…"` and `"countryOfOrigin": "CN"`.

### 🧠 Advanced usage

- 💸 **Competitor price and markdown tracking:** schedule the same categories daily. Join on `variants[].sku` and watch `price` / `wasPrice`.
- 🔬 **Catalogue matching:** join `variants[].ean` against your own range or another retailer's.
- 📈 **New-in monitoring:** `sort: "newest"` with a small `maxItemsPerQuery`, filtered by `releaseDate`.
- 💸 **Whole catalogue:** list the sub-categories of each department in `categories`. The run is de-duplicated, so overlapping categories are not charged twice.
- 💸 **Completion check:** read `RUN_SUMMARY`, which has `status` (`COMPLETE`, `PARTIAL`, `NO_PRODUCTS`, `BUDGET_LIMIT`, `TIME_LIMIT`, `STATE_SAVE_FAILED`, `INVALID_INPUT`, `NOT_CONFIGURED`), `products`, `charged`, and `queries[]` (each with `status`, `delivered`, `listed`, `warning`).

### 🔌 Integrations

Export as JSON, CSV or Excel; push to Google Sheets; trigger from Make, Zapier or n8n; get a webhook when a run finishes; schedule with the Apify Scheduler.

### 💸 How much does it cost?

1,000 products ≈ **$1.00** (all sizes and colours in one row); with the detail tier $4.00 / 1,000. Platform usage is included.

### 💰 Pricing

| Event | Price | Covers |
|---|---|---|
| `product` | $1.00 / 1,000 | One product row, **all sizes and colours included** |
| `product-detail` | $4.00 / 1,000 | One product row with the detail tier (`includeDetails`) and at least one of description, details & care, size & fit, or country of origin |

Platform usage is included. Status rows are free, and nothing is charged for failed requests. A run stops cleanly at your spending limit, with charges equal to rows delivered.

### ❓ FAQ

**Does it cover Dunnes groceries?** No. Groceries are on Dunnes' separate grocery site; this actor covers dunnesstores.com (fashion, home, kids, seasonal, school).

**Can I get exact stock levels?** No. Dunnes publishes availability per size, not quantities.

**Why did a category name come back NOT_FOUND?** Some names exist in several departments (e.g. `Clothing`). Use the path from the category URL, e.g. `women/clothing`.

### 🤖 For AI agents & LLM apps

`architekture/dunnes-ie-scraper` returns Dunnes Stores (Ireland) fashion and home products as deterministic, schema-stable JSON, one object per product. Each object has name, brand, EUR price range and sale flags, and every size and colour with SKU, EAN and availability; detail text is optional. Invoke it from any agentic workflow via the Apify API or the Apify MCP server (`mcp.apify.com`) as a tool call. Its cost is bounded before it starts: $1 per 1,000 products, or $4 per 1,000 with the detail tier. `maxItemsPerQuery` caps each query, and a spending limit stops the run cleanly. Every query gets a machine-readable status in `RUN_SUMMARY`, and misses come back as free `recordType: "query"` rows. Honest limits: dunnesstores.com only (no groceries), no stock counts, up to 2,500 products per query.

Works out of the box with LangChain, LlamaIndex and AI coding agents — call it as a tool from Claude Code, Cursor, or any MCP client via `mcp.apify.com`.

### 🧰 More Architekture scrapers

- 📍 **Ireland:** Dunnes Stores fashion & home (you are here) · [ALDI Ireland](https://apify.com/architekture/aldi-ie-scraper)
- **UK:** [Tesco UK](https://apify.com/architekture/tesco-uk-scraper) · [Sainsbury's UK](https://apify.com/architekture/sainsburys-uk-scraper)
- 🔎 **E-commerce:** [Shopify Products](https://apify.com/architekture/shopify-products-scraper) · [AliExpress Search](https://apify.com/architekture/aliexpress-search-scraper)

### 🙋 Support

Open an Issue on this actor's page; a human replies within a day.

### ⚖️ Legal compliance

This actor reads publicly available product data from dunnesstores.com's public catalogue API, without logging in. You are responsible for how you use the data, including Dunnes Stores' terms, intellectual property in product content and images, and data-protection law where it applies. Not affiliated with Dunnes Stores.

### 📝 Changelog

- 🔎 **2026-10-18**: 1.0. Search, category and product-URL modes; one row per product with sizes and colours nested; EAN per variant; per-size sale detection; detail tier charged only when published; free status rows; clean stops at spending limit and timeout; resumable after platform migration.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search on dunnesstores.com, e.g. jeans or duvet cover. Results are de-duplicated across all terms, categories and product URLs.

## `categories` (type: `array`):

Departments or categories by name (Home, Duvet Covers), path (women/clothing/jeans) or dunnesstores.com category URL. A category that does not exist gets one free status row.

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

Specific products by dunnesstores.com product URL (…/savida-stripe-jeans-7951169/p) or product id (36256). Up to 500.

## `maxItemsPerQuery` (type: `integer`):

0 = everything Dunnes' API pages (up to 2,500 per query; split big departments by category).

## `includeDetails` (type: `boolean`):

Adds the detail tier to each row. Rows that carry it are charged as product-detail; rows Dunnes publishes no detail for stay product. No extra requests.

## `sort` (type: `string`):

Order Dunnes returns results in (matters when maxItemsPerQuery cuts a result set).

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

Apify datacenter proxy is the tested default. Blocked or rate-limited requests are retried on a fresh IP.

## `feedback` (type: `string`):

Tell the maintainers what you needed and did not get. Read by a human; does not change the output.

## Actor input object example

```json
{
  "searchTerms": [
    "jeans"
  ],
  "maxItemsPerQuery": 50,
  "includeDetails": false,
  "sort": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per product, sizes/colours nested; misses add one free recordType: query row.

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

RUN_SUMMARY: status per query and charges.

# 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 = {
    "searchTerms": [
        "jeans"
    ],
    "maxItemsPerQuery": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("architekture/dunnes-ie-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 = {
    "searchTerms": ["jeans"],
    "maxItemsPerQuery": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("architekture/dunnes-ie-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 '{
  "searchTerms": [
    "jeans"
  ],
  "maxItemsPerQuery": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call architekture/dunnes-ie-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,architekture/dunnes-ie-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/ShEsgE8e4D7sSqgAP/builds/7zDZ4xulFTzqxRijU/openapi.json