# ASDA UK Product & Price Scraper (`dromb/asda-uk-product-price-availability`) Actor

ASDA UK product, price, promotion, taxonomy and store-scoped availability Actor.

- **URL**: https://apify.com/dromb/asda-uk-product-price-availability.md
- **Developed by:** [Dmitriy Gyrbu](https://apify.com/dromb) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 UK Grocery Product & Price Scraper

Collect live ASDA UK grocery search results, exact products, product batches, taxonomy listings, regional prices, promotions, ratings, and store-scoped availability in clean Dataset rows.

This Actor uses a lightweight first-party product index rather than browser automation. It is designed for repeatable price monitoring, grocery research, catalogue matching, and scheduled exports.

> This is an independent, unofficial Actor. It is not affiliated with, endorsed by, or sponsored by ASDA.

### Why use this Actor?

- **Simple operation-first input:** choose one workflow and provide one clear target.
- **Fast product search:** collect product cards for a grocery keyword.
- **Exact product lookup:** retrieve one ASDA product by CIN.
- **Batch matching:** retrieve up to 100 known CINs in one run.
- **Regional price fields:** select England, Scotland, Wales, or Northern Ireland source price and promotion fields.
- **Store-aware availability:** read the availability signal for a manually supplied commerce store ID.
- **Taxonomy monitoring:** collect products from known category or shelf IDs.
- **Query discovery:** retrieve live ASDA search suggestions.
- **Export-friendly output:** important identifiers, prices, availability, taxonomy, ratings, and promotions are available as flat top-level columns.
- **Honest data semantics:** the Actor does not fabricate product URLs, image URLs, GTIN verification, postcode mapping, or exact inventory quantities.

### Best use cases

| Buyer need | Recommended operation | What it returns |
|---|---|---|
| Keyword price monitoring | `search` | Product cards for a query such as `milk` |
| Exact product tracking | `product` | One product identified by ASDA CIN |
| Basket or catalogue matching | `products` | Up to 100 known CINs |
| Category assortment monitoring | `category` | Products from a known category ID |
| Shelf monitoring | `shelf` | Products from a known shelf ID |
| Store-aware availability checks | Any product operation + `storeId` | Availability signal for the selected commerce store |
| Keyword discovery | `suggestions` | ASDA query suggestions and ranking metrics |

### Supported operations

- `search`
- `product`
- `products`
- `category`
- `shelf`
- `suggestions`

The public operation names follow a simple grocery-workflow pattern. Existing integrations using legacy values such as `task: "exact_product"` or `task: "product_batch"` remain supported.

### Operation guide

The Console form shows the union of supported fields. Use this table to identify the target required by each operation.

| Operation | Required target | Useful options |
|---|---|---|
| `search` | `query` | `limit`, `page`, `storeId`, `priceRegion`, `inStockOnly` |
| `product` | `productId` | `storeId`, `priceRegion` |
| `products` | `productIds` | `storeId`, `priceRegion` |
| `category` | `categoryId` | `limit`, `page`, `storeId`, `priceRegion`, `inStockOnly` |
| `shelf` | `shelfId` | `limit`, `page`, `storeId`, `priceRegion`, `inStockOnly` |
| `suggestions` | `query` | `limit`, `page` |

### Quick start

The default input is deliberately small and inexpensive:

```json
{
  "operation": "search",
  "query": "milk",
  "limit": 8,
  "priceRegion": "EN",
  "storeId": "4565"
}
```

### Example inputs

#### Search products

```json
{
  "operation": "search",
  "query": "coffee",
  "limit": 20,
  "priceRegion": "EN",
  "storeId": "4565"
}
```

#### Search only products available at a store

```json
{
  "operation": "search",
  "query": "coffee",
  "limit": 20,
  "storeId": "4565",
  "priceRegion": "EN",
  "inStockOnly": true
}
```

#### Get one product

```json
{
  "operation": "product",
  "productId": "165468",
  "storeId": "4565",
  "priceRegion": "EN"
}
```

#### Get multiple products

```json
{
  "operation": "products",
  "productIds": ["165468", "2041527", "489747"],
  "storeId": "4565",
  "priceRegion": "EN"
}
```

#### Browse a category

```json
{
  "operation": "category",
  "categoryId": "1215660378320",
  "limit": 20,
  "storeId": "4565",
  "priceRegion": "EN"
}
```

#### Browse a shelf

```json
{
  "operation": "shelf",
  "shelfId": "1215339438036",
  "limit": 20,
  "storeId": "4565",
  "priceRegion": "EN"
}
```

#### Get query suggestions

```json
{
  "operation": "suggestions",
  "query": "mil",
  "limit": 5
}
```

### Product output

The default Products view puts the fields most useful in spreadsheets and monitoring workflows first.

```json
{
  "recordType": "product",
  "productId": "165468",
  "cin": "165468",
  "name": "British Milk Semi Skimmed 4 Pints",
  "brand": "ASDA",
  "packSize": "4 PINT",
  "currentPrice": 1.65,
  "wasPrice": 1.65,
  "currency": "GBP",
  "unitPriceFormatted": "72.6p/LT",
  "inStock": true,
  "availabilityStatus": "available",
  "storeId": "4565",
  "priceRegion": "EN",
  "category": "Milk",
  "department": "Fresh Food",
  "aisle": "Milk, Butter & Eggs",
  "shelf": "Milk",
  "ratingAverage": 4.7,
  "ratingCount": 120,
  "promotionCount": 0,
  "imageAssetId": "20337087",
  "scrapedAt": "2026-07-26T20:00:00Z"
}
```

The Actor also retains the original nested v1 objects—`identifiers`, `price`, `availability`, `taxonomy`, `promotions`, `rating`, and source warnings—so existing API integrations remain compatible.

### Dataset views

- **Products** — primary export-friendly product card.
- **Pricing & availability** — price, discount, promotion, store, and stock semantics.
- **Taxonomy** — category, department, aisle, and shelf IDs and names.
- **Suggestions & issues** — query suggestions and concise structured issues.
- **Legacy details** — original nested v1 fields for existing integrations.

Views improve the Apify Output tab. JSON, CSV, and Excel exports still contain the stored Dataset fields selected by the export request.

### Price and availability semantics

- `priceRegion` selects one of the regional source fields: `EN`, `SC`, `WA`, or `NI`. It is not geolocation and does not guarantee that regional values differ.
- `storeId` is a manually supplied ASDA commerce store identifier. Postcode-to-store conversion is not included.
- `inStockOnly: true` applies a positive-stock source filter for the selected store.
- Source stock value `999` is treated as an availability sentinel or cap, not an exact quantity.
- `inStock` is therefore a conservative availability signal; the Actor does not claim exact inventory.

### Identifier and media semantics

- `productId` and `cin` are the same proven ASDA CIN.
- `imageAssetId` is a source asset identifier. A product image URL is not fabricated when the exact URL contract is unproven.
- `gtinCandidate` is emitted only when the source identifier passes a checksum. It remains a candidate, not a verified barcode lookup.
- The Actor does not fabricate a product-page URL or a Shopper Products ID.

### Pricing

This Actor uses pay-per-event pricing:

- a small Actor-start charge;
- a result charge for each product, suggestion, or structured issue row written to the default Dataset;
- subscriber-tier discounts may apply.

Keep `limit` small while testing. Structured issue rows are Dataset results and may also be billable.

### Limits and reliability

- Coles-style default: 8 rows.
- Hard maximum: 1,000 rows per run.
- Maximum product batch: 100 CINs.
- Source page size: up to 100 products per request.
- Pagination stops when a source page repeats.
- Direct access is the proven default; browser automation is not used.
- Retryable source failures are retried within the configured bound.
- Failed source requests produce structured issue rows rather than silent empty success.

### Advanced connection settings

Most runs need no proxy. Advanced users can provide encrypted custom proxy URLs and choose direct-first, proxy-first, proxy-only, or direct-only ordering. Never place proxy credentials in public tasks, logs, or shared screenshots.

### Current boundaries

The following are intentionally **not** advertised as supported operations:

- full-catalogue crawling;
- weekly-specials or full promotions catalogue discovery;
- postcode-to-store mapping or Store Locator;
- product-page enrichment, ingredients, nutrition, reviews, or descriptions;
- verified barcode reverse lookup;
- exact stock quantities;
- fabricated product or image URLs.

Those features require separate source proof before they can be added to the public contract.

### Run summary

The default key-value store record `RUN_SUMMARY` contains the public operation, legacy task alias, status, result count, source metrics, limits, and structured errors without duplicating Dataset rows.

### Responsible use

Collect only publicly available product information. Do not use this Actor for unlawful activity, excessive load, personal-data collection, or attempts to bypass access controls. You are responsible for complying with applicable laws and source terms.

# Actor input Schema

## `operation` (type: `string`):

Choose one buyer workflow. Legacy task names remain accepted through the API but are hidden from the Console.

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

Required for search and suggestions. Example: milk, coffee, shampoo.

## `productId` (type: `string`):

ASDA CIN for the product operation. Product IDs are returned in every product row.

## `productIds` (type: `array`):

ASDA CINs for the products operation. Up to 100 unique IDs.

## `categoryId` (type: `string`):

Category taxonomy ID for the category operation. Copy it from a product result.

## `shelfId` (type: `string`):

Shelf taxonomy ID for the shelf operation. Copy it from a product result.

## `priceRegion` (type: `string`):

Select the England, Scotland, Wales, or Northern Ireland source price field. This does not geolocate the request.

## `storeId` (type: `string`):

ASDA commerce store ID used for store-scoped availability. Postcode conversion is not yet included.

## `inStockOnly` (type: `boolean`):

For listing operations, keep only products with positive source stock for the selected store.

## `limit` (type: `integer`):

Maximum Dataset rows. The Coles-style quick default is 8; hard maximum is 1,000.

## `page` (type: `integer`):

One-based starting page for search, category, shelf, and suggestions.

## `includeSponsored` (type: `boolean`):

Include sponsored products when the source returns them.

## `includePromotions` (type: `boolean`):

Include source promotion names and validity windows.

## `includeRatings` (type: `boolean`):

Include average rating and rating count when supplied.

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

Deterministic is recommended. Storefront parity adds source ranking hints while preserving hard filters.

## `hitsPerPage` (type: `integer`):

Results requested per source call. Maximum 100.

## `requestDelayMs` (type: `integer`):

Optional delay after successful source calls.

## `timeoutSecs` (type: `integer`):

Per-request timeout.

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

Retries for retryable network or source-response failures.

## `proxyMode` (type: `string`):

Direct access is the proven default. Custom proxy URLs are optional.

## `proxyUrls` (type: `array`):

Encrypted custom HTTP proxy URLs used only by proxy-enabled modes.

## `task` (type: `string`):

Backward-compatible task alias for API integrations. Prefer operation for new integrations.

## `cin` (type: `string`):

Backward-compatible alias for productId.

## `cins` (type: `array`):

Backward-compatible alias for productIds.

## `commerceStoreId` (type: `string`):

Backward-compatible alias for storeId.

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

Backward-compatible alias for limit.

## `pageStart` (type: `integer`):

Backward-compatible alias for page.

## Actor input object example

```json
{
  "operation": "search",
  "query": "milk",
  "productId": "165468",
  "productIds": [
    "165468",
    "2041527"
  ],
  "categoryId": "1215660378320",
  "shelfId": "1215339438036",
  "priceRegion": "EN",
  "storeId": "4565",
  "inStockOnly": false,
  "limit": 8,
  "includeSponsored": true,
  "includePromotions": true,
  "includeRatings": true,
  "mode": "deterministic",
  "hitsPerPage": 60,
  "requestDelayMs": 200,
  "timeoutSecs": 30,
  "maxRetries": 2,
  "proxyMode": "direct_only"
}
```

# Actor output Schema

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

Default Dataset product view.

## `pricingAvailability` (type: `string`):

Regional pricing, promotions, and store-scoped availability.

## `taxonomy` (type: `string`):

Category, department, aisle, and shelf hierarchy fields.

## `suggestionsIssues` (type: `string`):

Query suggestions and concise structured issue rows.

## `legacyDetails` (type: `string`):

Original nested v1 fields retained for existing integrations.

## `allResults` (type: `string`):

Raw default Dataset items including legacy nested fields.

## `outputSummary` (type: `string`):

Coles-style operation, success, total, source metrics, and structured errors.

## `runSummary` (type: `string`):

Operation, task alias, status, limits, source metrics, and structured errors.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("dromb/asda-uk-product-price-availability").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("dromb/asda-uk-product-price-availability").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 '{}' |
apify call dromb/asda-uk-product-price-availability --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dromb/asda-uk-product-price-availability",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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