# Asda Scraper - UK Groceries Products & Prices (`studio-amba/asda-scraper`) Actor

Scrape the full Asda groceries catalogue: product names, brands, prices, price-per-unit, promotions, ratings, images and categories. No cookies, no login.

- **URL**: https://apify.com/studio-amba/asda-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 37 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 result scrapeds

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

## Asda Scraper

Scrape the full Asda groceries catalogue from [asda.com/groceries](https://www.asda.com/groceries) — product names, brands, prices, price-per-unit, promotions, ratings, images and full category paths. No cookies, no login.

### Why use this actor?

Asda is one of the UK's big-four supermarkets, so its online prices are a benchmark for grocery price monitoring, competitor analysis, and product research. The storefront sits behind Cloudflare and has no public product feed, which makes it hard to collect at scale. This actor gives you the whole catalogue as clean, flat JSON rows you can drop straight into a spreadsheet, database, or price-tracking pipeline.

Typical users: pricing and category teams at other retailers and brands, market-research firms, price-comparison sites, and FMCG suppliers checking how their products are listed and priced.

### What you get

- The full browsable catalogue: about **48,900 distinct products**, deduplicated and complete.
- Prices pinned to a single delivery area (England by default) so runs are comparable over time.
- Price-per-unit (e.g. `£7.15/KG`), pack size, promotion labels (e.g. `Rollback`), ratings and review counts.
- Full category path (department > aisle > shelf) and a product image URL.

### How to scrape Asda data

1. Set **Max products**. Leave it low (e.g. 20) for a quick sample, or set it to 50000 to pull the whole catalogue of ~48,900 products.
2. Optionally set a **Search query** (for example `heinz baked beans` or `oat milk`) to search the catalogue by keyword instead of browsing categories. This uses Asda's own catalogue search, so results are the same products you'd find using the search box on the site.
3. Optionally set a **Category filter** to a single department name (for example `Frozen Food` or `Beer, Wine & Spirits`) to scrape just that part of the shop — this works standalone (full department) or combined with Search query (search within one department).
4. Pick a **Price zone**. Asda prices and availability vary by delivery area, so the actor pins one zone: England (`EN`, default), Northern Ireland (`NI`), Scotland (`SC`) or Wales (`WA`).
5. Provide a **Bright Data API key** (input field or the `BRIGHT_DATA_API_KEY` environment variable). It is used once per run to read the storefront's search key past Cloudflare — everything after that is read directly from the catalogue API.
6. Run the actor. Results stream into the dataset and can be exported as JSON, CSV, Excel or fed to an API.

Under the hood the actor reads Asda's own catalogue index directly: with no search query it walks the category tree and paginates each shelf (deduplicating every product by its Asda product ID, so you get each item once even when it appears in several promotions); with a search query it runs a keyword search against the same index instead, matching what you'd get from the site's own search box.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `maxProducts` | Integer | No | Maximum products to return (default 20; ~47000 for the full catalogue) |
| `searchQuery` | String | No | Search the catalogue by keyword, e.g. `heinz baked beans`. When set, replaces category browsing |
| `category` | String | No | Limit to one department, e.g. `Frozen Food`. Empty = whole catalogue. Can be combined with `searchQuery` |
| `priceZone` | String | No | Delivery area for prices: `EN` (default), `NI`, `SC`, `WA` |
| `brightDataApiKey` | String | Yes | Bright Data API key (or set `BRIGHT_DATA_API_KEY`). Used once per run |
| `proxyConfiguration` | Object | No | Proxy settings (optional; UK residential prefilled) |

### Output

Each result contains:

| Field | Type | Example |
|-------|------|---------|
| `name` | String | `"10 Mature Cheesy Slices 10x20g (200g)"` |
| `brand` | String | `"ASDA"` |
| `price` | Number | `1.43` |
| `currency` | String | `"GBP"` |
| `pricePerUnit` | String | `"£7.15/KG"` |
| `discount` | String | `"Rollback"` |
| `promotion` | String or null | `"Any 2 for £5"` |
| `promoValidFrom` | String or null | `"2026-09-11T00:00:00.000Z"` |
| `promoValidUntil` | String or null | `"2026-12-31T23:59:59.000Z"`. Null when Asda gives no end date or an end more than a year away (Asda stores far-future dates such as 2028 or 2033 on open-ended multibuys) |
| `packSize` | String | `"200g"` |
| `productId` | String | `"1000383274087"` |
| `ean` | String | `"5063089827420"` |
| `rating` | Number | `4` |
| `reviewCount` | Number | `5` |
| `imageUrl` | String | Scene7 product image URL |
| `category` | String | `"Chilled Food > Cheese > Grated & Sliced Cheese > Cheese Slices"` |
| `priceZone` | String | `"EN"` |
| `url` | String | Full product page URL |
| `scrapedAt` | String | ISO 8601 timestamp |

### Example output

```json
{
    "name": "10 Mature Cheesy Slices 10x20g (200g)",
    "brand": "ASDA",
    "price": 1.43,
    "currency": "GBP",
    "pricePerUnit": "£7.15/KG",
    "packSize": "200g",
    "productId": "1000383274087",
    "ean": "5063089827420",
    "inStock": true,
    "rating": 4,
    "reviewCount": 5,
    "imageUrl": "https://asdagroceries.scene7.com/is/image/asdagroceries/5063089827420",
    "category": "Chilled Food > Cheese > Grated & Sliced Cheese > Cheese Slices",
    "priceZone": "EN",
    "url": "https://www.asda.com/groceries/product/10-mature-cheesy-slices-10x20g-200g/1000383274087",
    "scrapedAt": "2026-07-03T10:30:00.000Z"
}
```

### Cost estimate

The catalogue is read from Asda's search API, which is fast and light. A full-catalogue run (~48,900 products) makes under 150 API calls plus a single Bright Data request. Most of the Apify cost is the per-result charge; the compute time is small because there is no browser rendering.

### Limitations

- Prices and stock are delivery-area scoped. The actor pins one zone (England by default) so numbers are consistent; prices in other zones may differ slightly.
- The browsable catalogue is about 48,900 products. Asda's search index reports a higher raw record count (~104,000), but those extra rows are secondary/variant entries the storefront collapses and never shows individually; this actor returns one clean row per browsable product.
- Barcodes (EAN) and brand are populated for effectively all food and grocery lines (>98%). They are sparser across the non-food General Merchandise range (books, DVDs, George Home), where Asda's feed does not carry an EAN. Filter to a grocery category if you need near-complete barcode coverage.
- Nutrition and long descriptions live on the individual product pages and are not included in this catalogue export.
- Data is scraped from the public website and may change without notice. Respect the website's terms of service and use responsibly.

### Compare prices across UK grocers

The [UK Grocery Price Matrix](https://apify.com/studio-amba/uk-grocery-price-matrix) runs this scraper alongside Tesco, Sainsbury's, Morrisons, Waitrose and Aldi UK, matches products by EAN barcode, and returns one row per product per retailer with the cheapest one flagged.

# Actor input Schema

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

Maximum number of products to return. Leave low for a quick sample; set to 50000 (or higher) for the full catalogue of ~48,900 distinct products.

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

Limit the scrape to one department. Use a top-level Asda category name exactly as shown on the site, e.g. 'Frozen Food', 'Chilled Food', 'Bakery', 'Beer, Wine & Spirits'. Leave empty to scrape the whole catalogue. Can be combined with Search query to scope a keyword search to one department.

## `searchQuery` (type: `string`):

Search the Asda catalogue by keyword instead of browsing categories, e.g. 'heinz baked beans' or 'oat milk'. When set, this replaces category browsing and returns matching products (respects Max products). Leave empty to browse by category / the whole catalogue as usual.

## `priceZone` (type: `string`):

Asda prices and availability are delivery-area scoped. Pick which zone's price to report. EN = England (default), NI = Northern Ireland, SC = Scotland, WA = Wales.

## `brightDataApiKey` (type: `string`):

Bright Data API key. Used once per run (a single Web Unlocker request) to harvest the Algolia search key from the Cloudflare-protected Asda storefront. Can also be set via the BRIGHT_DATA_API_KEY environment variable.

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

Proxy settings. The catalogue itself is read from Algolia directly, so a proxy is optional; a UK residential proxy is prefilled for robustness.

## Actor input object example

```json
{
  "maxProducts": 20,
  "category": "Frozen Food",
  "searchQuery": "heinz baked beans",
  "priceZone": "EN",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "maxProducts": 20,
    "priceZone": "EN",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "GB"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/asda-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 = {
    "maxProducts": 20,
    "priceZone": "EN",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "GB",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/asda-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 '{
  "maxProducts": 20,
  "priceZone": "EN",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  }
}' |
apify call studio-amba/asda-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/asda-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/yNrCVEAflAEtpboAW/builds/G4wcMLoQdENgK4iZV/openapi.json