# Argos Scraper \[$4💰] | UK Prices | Stock | Product Data (`ahmed_jasarevic/argos-scraper`) Actor

Argos scraper for UK product data: extract prices, was-prices, ratings, reviews, availability and delivery from argos.co.uk categories, search, clearance and product pages — no official Argos API needed. Optional detail mode adds descriptions, features, specs and images. From $0.004 per result.

- **URL**: https://apify.com/ahmed\_jasarevic/argos-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 $4.00 / 1,000 results

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

Extract Argos UK product prices, was-prices, stock availability, ratings and reviews for price monitoring, back-in-stock alerts and UK retail market research — no official Argos API needed. Run it once to build a product database, or schedule it in monitor mode to track price drops and stock changes over time, from $0.004 per result.

### What You Can Do With Argos Product Data

- **Argos price monitoring** — track current prices, was-prices and price movement across categories, search results or specific products
- **Price drop alerts** — monitor mode detects price drops and price rises between runs, with the exact price delta
- **Back-in-stock notifications** — get notified the moment an out-of-stock item is available again
- **UK retail market research** — analyze Argos assortment, pricing and ratings for competitor analysis and category intelligence
- **Building structured product databases** — export clean Argos product records (price, availability, specs, images) to a dataset
- **Retail arbitrage & bargain hunting** — spot clearance and price drops relative to was-prices across the catalog

### Scrape Argos Product Data Without an Official API

Argos (part of the Sainsbury's Group) does not offer a public product/pricing API, and its site is protected by Akamai, which blocks datacenter IPs. This actor handles that for you: pass category URLs, search keywords or direct product IDs, and it returns normalized product data as JSON in an Apify dataset. A RESIDENTIAL proxy group is required and configured by default via the Apify proxy.

### Track Argos Price Drops and Price Changes Over Time

Set `mode` to `monitor` and the actor compares every product against the previous run (state is persisted in a key-value store) and pushes only what changed — enriched with `changeType`, `previousPrice`, `priceDelta`, `firstSeenAt`, `lastSeenAt` and `changeCount`. Schedule the actor with `notifyOn` set to `price-drop` or `price-rise` and you get a rolling price-change feed for your watchlist.

### Monitor Argos Stock Availability and Get Back-in-Stock Alerts

The same monitor mode tracks stock status per product. Use `notifyOn` with `back-in-stock` or `out-of-stock` to report only the availability changes that matter, and keep separate watchlists independent by giving each its own `stateStoreName`.

### Build a Structured Argos Product Database

Enable `detail` to fetch every full product page (JSON-LD + HTML) and enrich records with description, features, specs, availability, delivery options, images and breadcrumbs. Combined with `category` plus `recurse` on hub pages, you can walk whole departments and assemble a structured Argos catalogue dataset for analysis or resale intelligence.

### Scraper Input: Category, Search and Product URLs

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | array | No | — | Category/browse, search, clearance or single product URLs, one per line |
| `category` | string | No | — | Scrape a whole browse category, e.g. `c:30049` or a full browse URL |
| `search` | string | No | — | Scrape Argos search results, e.g. `wireless headphones` |
| `product` | array | No | — | Direct product catalogue numbers or product URLs, one per line |
| `mode` | enum | No | `scrape` | `scrape` = push every product. `monitor` = compare with previous run and push only changes (price, stock/availability) |
| `notifyOn` | array | No | `["any-change"]` | Monitor reporting filter: `new`, `price-drop`, `price-rise`, `back-in-stock`, `out-of-stock`, `availability-change`, `changed`. Empty = any change |
| `stateStoreName` | string | No | `argos-monitor-state` | Key-value store that persists price/stock state between monitor runs. Use a different name per watchlist |
| `resetState` | boolean | No | `false` | Delete stored state before this run so every product is treated as new (fresh baseline) |
| `pages` | integer | No | `0` | Max listing pages to walk per category/search (0 = walk to the end) |
| `maxProducts` | integer | No | `2000` | Stop after this many unique products |
| `recurse` | integer | No | `0` | On category hub (CLP) pages, follow subcategory links up to this depth (0 = no recursion) |
| `maxHubs` | integer | No | `150` | Max subcategory links followed per hub page |
| `detail` | boolean | No | `false` | Fetch full product pages (JSON-LD + HTML) for description, features, specs, availability, delivery, images, breadcrumbs. Slower, more data per product |
| `detailConcurrency` | integer | No | `8` | Parallel product-detail requests when `detail` is enabled |
| `proxyConfiguration` | object | No | Apify `RESIDENTIAL` | Argos (Akamai) blocks datacenter IPs — a residential proxy group is required. Defaults to Apify RESIDENTIAL; own proxy URLs can be pasted |
| `maxRetries` | integer | No | `4` | Retries per URL on block, timeout or network error |
| `timeoutMs` | integer | No | `30000` | Per-request timeout in milliseconds |
| `concurrency` | integer | No | `5` | Parallel page/product fetches |
| `delayMs` | integer | No | `300` | Pause between listing pages to stay polite |

### Output Data: Prices, Ratings, Availability and More

Every product is pushed as one record to the Apify dataset. Fields are documented per run mode:

| Mode | Documented fields |
|---|---|
| `scrape` (base) | product URL, name, current price, was-price, currency (GBP), rating, review count, availability, delivery |
| `scrape` + `detail: true` | adds description, features, specs, images and breadcrumbs from the full product page |
| `monitor` | adds `changeType`, `previousPrice`, `priceDelta`, `firstSeenAt`, `lastSeenAt` and `changeCount` per changed product |

> The exact result set depends on the run mode. Run a small test scrape first to see the live field names before building your pipeline.

### Example Input

```json
{
  "search": "wireless headphones",
  "category": "c:30049",
  "product": ["7929184", "https://www.argos.co.uk/product/4584759"],
  "startUrls": ["https://www.argos.co.uk/browse/technology/laptops-and-pcs/laptops/c:30049/"],
  "maxProducts": 500,
  "pages": 3,
  "detail": false,
  "mode": "scrape"
}
```

Monitor example — report only price drops and back-in-stock items for a watchlist:

```json
{
  "search": "air fryer",
  "mode": "monitor",
  "notifyOn": ["price-drop", "back-in-stock"],
  "stateStoreName": "air-fryer-watchlist",
  "maxProducts": 200
}
```

### Example Output

Illustrative record based on documented fields (base scrape + monitor enrichment):

```json
{
  "url": "https://www.argos.co.uk/product/7929184",
  "name": "Wireless Noise Cancelling Headphones",
  "price": 79.99,
  "wasPrice": 99.99,
  "currency": "GBP",
  "rating": 4.4,
  "reviewCount": 2310,
  "availability": "In stock",
  "delivery": "Fast Track available",
  "changeType": "price-drop",
  "previousPrice": 99.99,
  "priceDelta": -20.00,
  "firstSeenAt": "2026-09-12T08:00:00Z",
  "lastSeenAt": "2026-09-19T10:30:00Z",
  "changeCount": 2
}
```

### Integrations & Automation

The actor runs on the Apify platform, so you get the Apify API, webhooks and scheduled runs out of the box, plus Apify's integration panel (Zapier, Make, Google Sheets, Slack and others).

Recommended schedules for recurring use:

- **Price monitoring** — run `monitor` daily to catch price drops and rises across your product watchlist
- **Stock / back-in-stock alerts** — run `monitor` hourly or every few hours for high-demand items; each monitoring event is billed at $0.0005
- **Product database refresh** — run `scrape` weekly (or per sale season) with `detail: true` to refresh descriptions, specs and images

### Related Actors

- [Argos.co.uk Scraper (Pay Per Result)](https://apify.com/123webdata/argos-scraper) — Argos product data extractor with XLSX/CSV/JSON output
- [Argos UK Product Scraper](https://apify.com/sync-network/argos-product-scraper) — search, category and product-page scraping for Argos.co.uk
- [Argos UK Product Search & Catalog](https://apify.com/dromb/argos-uk-product-search-catalog-unofficial) — Argos UK product search results and catalog listings
- [Argos Price Tracker](https://apify.com/truefetch/argos-price-tracker) — Argos price snapshots via keyword search

### FAQ

#### Why use this actor instead of the official Argos API?

Argos does not offer a public API for product prices, stock or catalogue data. Its site is protected by Akamai and blocks datacenter IPs, which is exactly what this actor handles — residential proxies are configured by default and per-URL retries handle blocking and timeouts.

#### Is there an Argos price history or price tracker?

There is no official Argos price history. Monitor mode builds your own: state persists across runs and every changed product is enriched with `previousPrice`, `priceDelta`, `firstSeenAt`, `lastSeenAt` and `changeCount`, so a scheduled run gives you a continuous price-change log.

#### How can I check Argos stock and get back-in-stock alerts?

Run in `monitor` mode with `notifyOn` set to `back-in-stock` (and optionally `out-of-stock`). Availability is compared with the previous run and only changed products are pushed, so a scheduled monitor gives you restock alerts without re-processing the whole catalogue.

#### How do I scrape an entire Argos category or department?

Pass a browse category URL (or `c:ID`) to `category`, set `recurse` to follow subcategory hub pages, and cap the run with `maxProducts` and `pages`. With `detail: true` you also get specs, images and breadcrumbs for each product.

#### What proxies does this actor need for Argos?

Argos uses Akamai protection that blocks datacenter IPs, so a RESIDENTIAL proxy group is required. The default configuration uses the Apify proxy with the `RESIDENTIAL` group — you can also paste your own residential proxy URLs.

#### What alternatives to this actor exist for Argos data?

On Apify's Store there are several other Argos actors, mostly plain scrapers or snapshot services (prices range from roughly $0.40 to $7.80 per 1,000 results across the category). Off-platform commercial Argos APIs also exist. This actor is differentiated by its stateful monitor mode, which tracks price deltas and stock changes across runs instead of only returning point-in-time snapshots.

### SEO Keywords

argos scraper, argos.co.uk scraper, argos product scraper, argos price tracker, argos price monitoring, argos price drop alerts, argos price history, argos price comparison, argos stock checker, argos stock availability, argos back in stock alerts, argos restock alerts, argos product data, argos product database, argos data extraction, argos api alternative, argos scraping api, argos clearance tracker, argos sale tracking, uk retail price monitoring, uk e-commerce data, argos ratings and reviews, argos product specs, uk price intelligence

### For AI Agents & LLM Apps

**Purpose:** Returns Argos UK product records (price, was-price, currency, rating, review count, availability, delivery) for category, search or product-URL inputs; with `mode: "monitor"` it returns only products that changed since the previous run, enriched with price/stock change metadata.

**Minimal working input:**

```json
{ "search": "air fryer", "maxProducts": 10 }
```

**Variant input (monitor / watchlist):**

```json
{ "search": "air fryer", "mode": "monitor", "notifyOn": ["price-drop", "back-in-stock"], "stateStoreName": "watchlist-a", "maxProducts": 200 }
```

**Output fields:** `url`, `name`, `price`, `wasPrice`, `currency`, `rating`, `reviewCount`, `availability`, `delivery`; plus `description`, `features`, `specs`, `images`, `breadcrumbs` when `detail` is true; plus `changeType`, `previousPrice`, `priceDelta`, `firstSeenAt`, `lastSeenAt`, `changeCount` in `monitor` mode.

**Behaviors an agent should know:**

- **Residential proxy required.** The default `proxyConfiguration` uses Apify `RESIDENTIAL`. A run with datacenter-only exits will fail — do not override the proxy config unless you supply working residential proxies.
- **Bound your run to control cost.** `maxProducts` (default 2000) and `pages` (default 0 = walk to the end) cap the results. Leaving them unset on a large category can produce a long, expensive run.
- **`detail: true` is extra-billed** — each full product page adds a separate detail event ($0.001 per event) on top of the $0.004 result price.
- **Monitor mode state is sticky.** The key-value store named by `stateStoreName` persists across runs; the same store name reuses the previous baseline. Use `resetState: true` or a fresh `stateStoreName` to start a new baseline.
- **`notifyOn` filtering.** In `monitor` mode an empty `notifyOn` array means "report every detected difference" (same as `any-change`). Set specific values to restrict what's pushed.
- **Inputs are complementary, not mutually exclusive** — `startUrls`, `category`, `search` and `product` can be combined in one run.

**Billing model (pay-per-event):** $0.004 per result, $0.001 per detail event (when `detail` is enabled), $0.0005 per monitoring event (in `monitor` mode), plus a per-GB actor-start event. ~$4 per 1,000 results in `scrape` mode.

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Argos Limited or the Sainsbury's Group. It reads publicly available pages on argos.co.uk (category, search and product pages) and does not require a customer account or login to run.

Users are responsible for ensuring their use of this actor complies with argos.co.uk's Terms of Service and applicable law, including UK data-protection rules (e.g. UK GDPR) where relevant. Respect robots/terms, request rates, and do not use extracted data in ways that violate the source site's terms.

# Actor input Schema

## `startUrls` (type: `array`):

Category/browse, search, clearance or single product URLs. One per line.

## `category` (type: `string`):

Scrape a whole browse category, e.g. c:30049 or a full browse URL.

## `search` (type: `string`):

Scrape Argos search results, e.g. wireless headphones.

## `product` (type: `array`):

Direct product catalogue numbers or product URLs (one per line).

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

scrape = push every product as found. monitor = compare each product with the previous run (state kept in a key-value store) and push only what changed (price, stock/availability), enriched with changeType, previousPrice, priceDelta, firstSeenAt, lastSeenAt and changeCount. Schedule the Actor for price/stock tracking.

## `notifyOn` (type: `array`):

Which changes to push in monitor mode (one per line): any-change (report every detected difference), new, price-drop, price-rise, back-in-stock, out-of-stock, availability-change, changed. Leave empty for any-change.

## `stateStoreName` (type: `string`):

Key-value store (persists across runs) that remembers the previous price/stock per product. Use a different name to keep separate watchlists independent.

## `resetState` (type: `boolean`):

Delete the stored state before this run, so every product is treated as new (fresh baseline).

## `pages` (type: `integer`):

Max listing pages to walk per category/search (0 = walk to the end).

## `maxProducts` (type: `integer`):

Stop after this many unique products.

## `recurse` (type: `integer`):

If the URL is a category hub page, follow its subcategory links up to this depth (0 = do not recurse).

## `maxHubs` (type: `integer`):

Caps how many subcategory links are followed per hub page.

## `detail` (type: `boolean`):

Also fetch every product page (JSON-LD + HTML) for description, features, specs, availability, delivery, images and breadcrumbs. Slower, but more data per product.

## `detailConcurrency` (type: `integer`):

Parallel product-detail requests when detail is enabled.

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

Proxies used to load Argos pages. Argos is protected by Akamai, which blocks datacenter IPs, and it currently rejects UK/EU residential exits too — a RESIDENTIAL proxy group is required. With the Apify proxy the scraper automatically rotates exit countries (worldwide/US/CA/AU) and ignores the country set here. Default: Apify RESIDENTIAL. You can also paste your own proxy URLs instead.

## `maxRetries` (type: `integer`):

Retries per URL on block, timeout or network error.

## `timeoutMs` (type: `integer`):

Per-request timeout in milliseconds.

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

Parallel page/product fetches.

## `delayMs` (type: `integer`):

Pause between listing pages to stay polite.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.argos.co.uk/browse/technology/laptops-and-pcs/laptops/c:30049/"
  ],
  "product": [],
  "mode": "scrape",
  "notifyOn": [
    "any-change"
  ],
  "stateStoreName": "argos-monitor-state",
  "resetState": false,
  "pages": 0,
  "maxProducts": 2000,
  "recurse": 0,
  "maxHubs": 150,
  "detail": false,
  "detailConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxRetries": 4,
  "timeoutMs": 30000,
  "concurrency": 5,
  "delayMs": 300
}
```

# Actor output Schema

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

One record per scraped product (scrape mode) or per detected change (monitor mode): id, url, title, brand, price, was-price, rating, reviews, images, description, specs, breadcrumbs, ...

# 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 = {
    "startUrls": [
        "https://www.argos.co.uk/browse/technology/laptops-and-pcs/laptops/c:30049/"
    ],
    "category": "",
    "search": "",
    "product": [],
    "notifyOn": [
        "any-change"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/argos-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 = {
    "startUrls": ["https://www.argos.co.uk/browse/technology/laptops-and-pcs/laptops/c:30049/"],
    "category": "",
    "search": "",
    "product": [],
    "notifyOn": ["any-change"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/argos-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 '{
  "startUrls": [
    "https://www.argos.co.uk/browse/technology/laptops-and-pcs/laptops/c:30049/"
  ],
  "category": "",
  "search": "",
  "product": [],
  "notifyOn": [
    "any-change"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call ahmed_jasarevic/argos-scraper --silent --output-dataset

```

## MCP server setup

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