# Malaysia Grocery Prices & Promo Tracker

The Malaysia Grocery Prices and Promo Tracker returns one normalised row per product from three sources: 99 Bulksales, Jaya Grocer's Shopify catalogue and the KPDN PriceCatcher open dataset. Each row carries the parsed pack spec, price in RM, price per pack, price per kg, litre or piece, promo and stock flags, and an optional changeType against the previous run. Rows cost $1.00 per 1,000. Run it from Apify Console or the API.

## Key facts

- Price: from $0.001 per product price row, $1.00 per 1,000
- Pricing model: Pay per event
- Output: JSON, CSV, Excel, XML, RSS via Apify datasets
- Access: Apify Console, REST API, Python and JS clients, MCP tool my_grocery_prices
- Version: Updated Nov 2026, build 0.1.3
- Usage: 100.0% successful runs (30 days)
- Actor: subimpact/my-grocery-prices

## Who it is for

- Grocery analysts comparing shelf prices across Malaysian chains
- FMCG brands tracking promo depth and unit price on key SKUs
- Price monitoring teams watching basket costs week to week
- Journalists and researchers using official PriceCatcher data without parsing parquet

## Use cases

### Compare the same item across three sources

Leave sources at all three and set searchTerms to a brand such as maggi. Rows from 99bulksales, jayagrocer and pricecatcher share one schema, so unitPriceRm and unitPriceBasis put a 12 by 500 g carton beside a 2 kg bag beside a wet market kilo on the same footing, and itemKey gives every row a stable identity.

### Track price moves between runs

Turn on trackChanges with a stateKey such as weekly-kl and each row gains changeType of new, price_up, price_down, promo_start, promo_end or unchanged, plus previousPriceRm. Add onlyChanges true and the run delivers and charges only rows that actually moved, which keeps a large weekly sweep cheap.

### Use official PriceCatcher prices

Filter the pricecatcher source with pcRetailers such as lotuss, aeon, mydin and 99speedmart, pcStates such as Selangor or Johor, and pcItemCategories such as AYAM or BERAS. Each row carries outletName, outletState, outletDistrict and priceDate, with the KPDN attribution string kept in the attribution field for redistribution.

### Normalise pack sizes for a basket

packSpec keeps the raw text such as 12*500G or 4*6*2*225G, while packCount, unitSizeValue and totalQuantityValue turn it into numbers. That means a basket comparison can weight by total grams instead of pack count, and rows where packParseStatus is unparsed are flagged rather than quietly given a guessed size.

### Watch promos start and stop

isPromo comes from the PROMO badge on 99 Bulksales and from a compare_at_price above the price on Jaya Grocer. With change tracking on, promo_start and promo_end mark the transition, and compareAtPriceRm keeps the pre-promo figure. PriceCatcher has no promo field, so isPromo is null on those rows rather than a guess.

## Price events

- Product price row (`product-row`): $0.001, lowest tier $0.001. One normalised product price row delivered

Prices from the Apify Store. Apify shows the final price before each run.

## How it compares with other Apify actors

Price per 1,000 products at Apify Store list prices, checked 20 Nov 2026.

| Actor | Price per 1,000 products (Free plan) | Higher plans (Gold) | Start fee per run | Platform usage | Users | Rating | Last build |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Malaysia Grocery Prices & Promo Tracker (this API) | $1.00 | $1.00 | None | Paid separately | 2 | No reviews yet | 20 Nov 2026 |
| [GrabFood & GrabMart Scraper — Restaurants, Stores & Products](https://apify.com/polyglot-data/grabfood-scraper) | Charges per store event plus a menu event, not per grocery product price row. | Same unit, see the first price column | $0.00005 | Included | 45 | No reviews yet | 13 Nov 2026 |
| [Foodpanda Scraper - Restaurants, Menus & Leads](https://apify.com/scrapesage/foodpanda-scraper) | Charges per restaurant event with a full menu event as an option, not per product row. | Same unit, see the first price column | None | Included | 37 | No reviews yet | 2 Nov 2026 |

### Where GrabFood & GrabMart Scraper — Restaurants, Stores & Products is stronger

- Covers GrabMart grocery stores across several Southeast Asian markets
- Product rows include barcode, department and discount fields
- Restaurant and menu data come from the same actor

### Where this API is stronger

- Normalised unit prices in ringgit per kilogram, litre or piece
- Run to run change tracking with previous price fields
- Government PriceCatcher survey data sits alongside retailer prices

### Where Foodpanda Scraper - Restaurants, Menus & Leads is stronger

- A vertical input lets a run target grocery rather than restaurants
- Monitor mode returns only new and changed records
- Menu rows can be returned in the local language

### Where this API is stronger

- Built around pack sizes and unit prices per kilogram, litre or piece
- Three sources in one schema, including the official survey
- Plain HTTP with no proxy in the default configuration

Malaysian grocery price coverage on the Store is thin. polyglot-data reaches GrabMart grocery products through a store and menu scraper, and scrapesage covers foodpanda with an optional grocery vertical, but neither parses pack sizes or compares government survey prices. That normalisation and the change tracking is what this actor adds.

Prices are Apify Store list prices, checked 20 Nov 2026. Platform usage 'Paid separately' means Apify bills compute on top of the event price. Check each listing before you buy.

## Input

- `sources` (array, optional): Retailer and open-data sources to collect. 99 Bulksales is a wholesale catalogue (sitemap discovery, product pages), Jaya Grocer is a Shopify storefront (/products.json), PriceCatcher is the KPDN open dataset on data.gov.my.
- `searchTerms` (array, optional): Optional. Every word of a term must appear in the product name or slug (case-insensitive). Leave empty to collect the catalogue in source order. The prefill ["maggi"] is a small example run.
- `maxItemsPerSource` (integer, optional): Cap on delivered rows for each source. 99 Bulksales and PriceCatcher stop fetching once the cap is reached; Jaya Grocer stops paging. Default 15 per source = up to 45 rows.
- `jayaProductTypes` (array, optional): Optional. Keep only Jaya Grocer products whose product_type equals one of these values (case-insensitive), e.g. Beverages, Frozen.
- `pcRetailers` (array, optional): Premise-name patterns used to keep PriceCatcher outlets. Food courts and restaurants are always excluded.
- `pcStates` (array, optional): Optional. Keep only outlets in these states, matched case-insensitively (e.g. Selangor, Johor, W.P. Kuala Lumpur).
- `pcItemCategories` (array, optional): Optional. Keep only these PriceCatcher item categories, matched case-insensitively (e.g. AYAM, BERAS, MINYAK DAN LEMAK).
- `pcLookbackDays` (integer, optional): Window ending at the newest date in the data. The latest observation per outlet and item inside the window is returned.
- `pcIncludeCookedFood` (boolean, optional): PriceCatcher also prices cooked dishes (item group MAKANAN SIAP MASAK). Off by default so the feed stays comparable grocery items.
- `trackChanges` (boolean, optional): Compare each row with the last run stored under stateKey and add changeType (new, price_down, price_up, promo_start, promo_end, unchanged), previousPriceRm and previousIsPromo.
- `stateKey` (string, optional): Separate change-tracking history per key, e.g. one per product list or region. Sanitised to A-Z, a-z, 0-9, _ and - (max 50 characters).
- `onlyChanges` (boolean, optional): When trackChanges is on, deliver and charge only rows whose changeType is not unchanged. Requires trackChanges.

### Example input

```json
{
  "searchTerms": [
    "maggi"
  ]
}
```

## Output fields

- `source` (string): 99bulksales, jayagrocer or pricecatcher
- `retailer` (string/null): Retailer or institution label for the row
- `itemKey` (string/null): Stable row identity: 99bulksales:<slug>, jayagrocer:<variantId>, pricecatcher:<premise_code>:<item_code>
- `productName` (string/null): Product name as published by the source
- `productUrl` (string/null): Product page; null for open-data rows
- `productCategory` (string/null): Jaya Grocer product_type or PriceCatcher item_category; null for 99 Bulksales
- `productGroup` (string/null): PriceCatcher item_group; null elsewhere
- `seller` (string/null): Jaya Grocer vendor (seller entity); null elsewhere
- `sku` (string/null): Jaya Grocer variant SKU; null elsewhere
- `outletName` (string/null): PriceCatcher premise name
- `outletAddress` (string/null): PriceCatcher premise address
- `outletType` (string/null): PriceCatcher premise_type
- `outletState` (string/null): PriceCatcher premise state
- `outletDistrict` (string/null): PriceCatcher premise district
- `packSpec` (string/null): Raw pack-size text that was parsed, e.g. 12*500G or 1kg
- `packCount` (integer/null): Number of packs, sachets or pieces in the listing
- `unitSizeValue` (number/null): Size of one pack in g or ml; null when the listing is sold by piece
- `unitSizeUnit` (string/null): g, ml or pcs
- `totalQuantityValue` (number/null): packCount x unitSizeValue, or the piece count for piece listings
- `totalQuantityUnit` (string/null): g, ml or pcs
- `packParseStatus` (string/null): parsed or unparsed
- `priceRm` (number/null): Listing price in Malaysian ringgit
- `compareAtPriceRm` (number/null): Jaya Grocer compare_at_price when present
- `isPromo` (boolean/null): True when the source flags a promotion or shows a higher compare-at price
- `pricePerPackItemRm` (number/null): priceRm divided by packCount
- `unitPriceRm` (number/null): Price per kg, per litre or per piece
- `unitPriceBasis` (string/null): per kg, per litre or per piece
- `inStock` (boolean/null): Availability as published by the source
- `stockNote` (string/null): Stock or purchase-limit text, e.g. Limit 10 quantity per customer
- `isNonHalal` (boolean/null): True when 99 Bulksales shows the Non-Halal Product label; null elsewhere
- `priceDate` (string/null): PriceCatcher observation date (YYYY-MM-DD); null elsewhere
- `changeType` (string/null): new, price_down, price_up, promo_start, promo_end or unchanged (only when trackChanges is on)
- `previousPriceRm` (number/null): Price in the previous tracked run
- `previousIsPromo` (boolean/null): Promo flag in the previous tracked run
- `attribution` (string/null): Required attribution text for open-data rows
- `scrapedAt` (string): ISO 8601 timestamp of this run
- `error` (string/null): Set on an error row when a source returned an unrecognised response; error rows are never charged

## Sample output

Trimmed from one of our own test runs. Personal data is redacted.

```json
[
  {
    "source": "99bulksales",
    "retailer": "99 Speedmart (99 Bulksales)",
    "itemKey": "99bulksales:drypers-wee-wee-dry-tape-xl-450s",
    "productName": "DRYPERS WEE WEE DRY TAPE XL 4*50S",
    "productUrl": "https://www.99bulksales.my/shop/product/drypers-wee-wee-dry-tape-xl-450s",
    "productCategory": null,
    "productGroup": null,
    "seller": null,
    "sku": null,
    "outletName": null,
    "outletAddress": null,
    "outletType": null,
    "outletState": null,
    "outletDistrict": null,
    "packSpec": "4*50S",
    "packCount": 200,
    "unitSizeValue": null,
    "unitSizeUnit": "pcs",
    "totalQuantityValue": 200,
    "totalQuantityUnit": "pcs",
    "packParseStatus": "parsed",
    "priceRm": 122.5,
    "compareAtPriceRm": null,
    "isPromo": false,
    "pricePerPackItemRm": 0.61,
    "unitPriceRm": 0.61,
    "unitPriceBasis": "per piece",
    "inStock": true,
    "stockNote": "Limit 8 quantity per customer",
    "isNonHalal": false
  },
  {
    "source": "99bulksales",
    "retailer": "99 Speedmart (99 Bulksales)",
    "itemKey": "99bulksales:kca-tisu-dapur-860s6-gulung",
    "productName": "KCA TISU DAPUR 8*60S*6 GULUNG",
    "productUrl": "https://www.99bulksales.my/shop/product/kca-tisu-dapur-860s6-gulung",
    "productCategory": null,
    "productGroup": null,
    "seller": null,
    "sku": null,
    "outletName": null,
    "outletAddress": null,
    "outletType": null,
    "outletState": null,
    "outletDistrict": null,
    "packSpec": null,
    "packCount": null,
    "unitSizeValue": null,
    "unitSizeUnit": null,
    "totalQuantityValue": null,
    "totalQuantityUnit": null,
    "packParseStatus": "unparsed",
    "priceRm": 79.9,
    "compareAtPriceRm": null,
    "isPromo": true,
    "pricePerPackItemRm": null,
    "unitPriceRm": null,
    "unitPriceBasis": null,
    "inStock": true,
    "stockNote": "Limit 10 quantity per customer",
    "isNonHalal": false
  }
]
```

## How to run it

1. Choose sources from 99bulksales, jayagrocer and pricecatcher, and optionally narrow with searchTerms such as maggi.
2. Set maxItemsPerSource, for example 100, and for PriceCatcher pick pcRetailers, pcStates and pcItemCategories with a pcLookbackDays window.
3. Turn on trackChanges with a stateKey for the history you want, and onlyChanges if you only care about movement.
4. Run the actor. Rows land in the dataset with pack sizes, RM prices, unit prices and promo flags already computed.
5. Export as JSON, CSV or Excel, or read the same rows through the Apify API.

### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/subimpact~my-grocery-prices/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["maggi"]}'
```

### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("subimpact/my-grocery-prices").call(run_input={
      "searchTerms": [
        "maggi"
      ]
    })

for item in client.dataset(run["default_dataset_id"]).iterate_items():
    print(item)
```

### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('subimpact/my-grocery-prices').call({
  "searchTerms": [
    "maggi"
  ]
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(items);
```

### MCP

```bash
claude mcp add subimpact-data -e APIFY_TOKEN=<YOUR_APIFY_TOKEN> -- npx -y @subimpact/data-mcp

# Then ask your agent to use the my_grocery_prices tool.
```

### n8n

Use the Apify node (Run an Actor).
Actor ID: subimpact/my-grocery-prices
Input JSON: paste the example input below.

## Limits

- 99 Bulksales is read through its sitemap only, since robots.txt disallows its search and paging URLs.
- PriceCatcher is a survey with an observation date, not a live checkout price.
- Pack parsing is a heuristic, so some names arrive with unparsed pack fields.
- One Jaya Grocer product can produce several rows, one per variant.

## FAQ

### What does a row cost?

Each delivered product price row costs $0.001, so $1.00 per 1,000 rows, with no start fee. A default run of three sources at 15 rows each stays under five cents. Error rows and empty rows are not charged, and with onlyChanges on you pay only for rows that moved.

### Which sources does it cover?

Three: 99 Bulksales, the 99 Speedmart wholesale catalogue, read from its product sitemap and pages; Jaya Grocer, read from its Shopify products.json catalogue; and KPDN PriceCatcher, the government price survey on data.gov.my, filtered to the grocery chains you choose.

### How are unit prices calculated?

pricePerPackItemRm divides the price by the pack count, and unitPriceRm gives the price per kg for gram packs, per litre for millilitre packs and per piece for piece counts, with money rounded to two decimals. The same rule applies to all three sources, which is what makes the rows comparable.

### What happens when a pack size cannot be read?

The row is still delivered, with packParseStatus set to unparsed and the pack fields null rather than a guessed number. PriceCatcher units such as sepinggan or gelas kecil are unparsed by design, and the raw text always survives in packSpec.

### Is PriceCatcher live checkout data?

No. It is a price survey, so each row carries priceDate, the observation date, along with outlet address, type and district from the government lookup files. Treat it as the published survey price on that date, not as availability or a live checkout figure.

### How does change tracking store history?

In a key-value store record keyed by your stateKey, holding price and promo flag per itemKey. The first tracked run marks everything as new, state is saved every 500 rows so a timed-out run keeps progress, and a separate stateKey keeps unrelated product lists from overwriting each other.

### Can I get cooked food prices too?

Yes, with pcIncludeCookedFood true, which brings in PriceCatcher dishes under the MAKANAN SIAP MASAK group. It is off by default so the feed stays comparable grocery items, and food courts and restaurants are always excluded from the outlet filter.

## Links

- Page: https://subimpact.net/apis/my-grocery-prices/
- Category: https://subimpact.net/apis/category/ecommerce/
- Run on Apify: https://apify.com/subimpact/my-grocery-prices
- All data APIs: https://subimpact.net/apis/
- Catalogue JSON: https://subimpact.net/apis/catalogue.json
