# 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
- **Stats:** 2 total users, 0 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# 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"` |
| `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.

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API — maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

# 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"
  }
}
```

# 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("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=studio-amba/asda-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/yNrCVEAflAEtpboAW/builds/fdoDzpm6hOa9QSsWn/openapi.json