# Amazon UK Search & Product Scraper (`commercestack/amazon-uk-search-product-scraper`) Actor

CommerceStack collects Amazon.co.uk search results, ASIN details and seller catalogs. Monitor product prices with verified UK delivery context and GBP. Use via API or Apify MCP.

- **URL**: https://apify.com/commercestack/amazon-uk-search-product-scraper.md
- **Developed by:** [Aleksandr Karavaev](https://apify.com/commercestack) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.50 / 1,000 full products

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

## Amazon UK Search & Product Scraper

CommerceStack collects Amazon.co.uk search results, product details by ASIN and seller catalog listings with a verified British delivery postcode and GBP currency. No Amazon account or external scraping subscription is required. The Actor makes its own source requests and never launches another Actor.

### Use with ChatGPT, Claude and AI agents

This CommerceStack Actor is available through the [official Apify MCP server](https://docs.apify.com/mcp). It is an Apify tool, not a separate built-in CommerceStack app in every AI assistant. The client must support remote MCP and be connected to your Apify account. Actor runs use the current Apify pricing.

- **Claude:** connect the [official Apify connector](https://claude.com/marketplace/connectors/apify), then name `commercestack/amazon-uk-search-product-scraper` in your request.
- **ChatGPT:** where your account and workspace allow custom MCP plugins, follow [OpenAI's connection instructions](https://developers.openai.com/api/docs/guides/custom-mcp-server). Use the server URL below and Apify OAuth.
- **Cursor, Claude Code, Codex and other MCP clients:** add the same remote server using the client's MCP configuration. See [Apify client setup](https://docs.apify.com/mcp). OAuth avoids pasting an API token into a conversation.

For this Actor plus its description, input schema and current pricing, use:

```text
https://mcp.apify.com?tools=fetch-actor-details,commercestack/amazon-uk-search-product-scraper
```

Copy this first-run prompt:

> Use commercestack/amazon-uk-search-product-scraper to look up ASIN B09Y2MYL5C, maximum one product, for delivery to SW1A 1AA in GBP. Read the schema and current pricing first. Return the title, featured-offer price or its explicit unavailable state, and deliveryContext. Inspect MANIFEST and report technical errors.

Before running, check the input schema, choose page/item limits and review the cost. Read the Dataset together with `MANIFEST`; an assistant should not infer a missing product, a final checkout price or complete coverage from an incomplete response. For repeated monitoring, keep the same watchlist key and delivery context and follow the monitoring instructions below.

#### Ready-to-use examples

Duplicate an example into your own Apify account and edit its input before running. Copying an example does not start it or enable a schedule.

- [Collect Amazon UK search results by keyword](https://apify.com/commercestack/amazon-uk-search-product-scraper/examples/amazon-uk-keyword-search)
- [Track Amazon UK product price changes](https://apify.com/commercestack/amazon-uk-search-product-scraper/examples/amazon-uk-price-monitor)

### Pick your workflow

- **Price monitoring:** compare the same ASINs over time in a verified delivery postcode and currency. [Set up a saved task](#start-a-price-monitor).
- **One-off product data:** use `lookup_only` for identity, images and the featured offer; use `products` for source-visible full-card fields.
- **Product discovery:** use `search_only` or `seller_catalog`, then look up a selected list of ASINs.

Amazon marketplaces have separate Actors: [US](https://apify.com/commercestack/amazon-us-search-product-scraper), [Germany](https://apify.com/commercestack/amazon-de-search-product-scraper), [UK](https://apify.com/commercestack/amazon-uk-search-product-scraper). Keep each market and delivery context in its own watchlist.

### Quick start

Product lookup:

```json
{"mode":"lookup_only","products":["B09Y2MYL5C"],"maxItems":1}
```

Search:

```json
{"mode":"search_only","queries":["sony headphones"],"maxPagesPerSource":2,"maxItems":40}
```

Full cards:

```json
{"mode":"products","products":["B09Y2MYL5C","B08C7KG5LP"],"maxItems":2}
```

Seller catalog:

```json
{"mode":"seller_catalog","sellerIds":["A3P5ROKL5A1OLE"],"maxPagesPerSource":2,"maxItems":40}
```

Use `products` with `queries` to discover and hydrate results, or `seller_catalog` with `enrichProducts: true` to hydrate catalog listings. Page and item limits produce bounded coverage, not a complete-market or complete-catalog claim.

### Output

| Mode | Fields |
|---|---|
| search_only | ASIN, title, product URL, cover image, displayed price/rating and source placement |
| lookup_only | Identity, title, image gallery, featured price or explicit no-price state, seller and verified delivery context |
| products | Lookup fields plus source-visible attributes, bullets, description, categories, observed variants and A+ content |
| seller_catalog | Merchant-filtered listing traversal with optional full-card enrichment |

With monitoring off, filter dataset rows using `recordType: product`. With `monitor: true`, consume `recordType: monitor` instead; a product-only filter would hide every monitoring observation. Free `occurrence` rows preserve query/page/rank relations. Always inspect `MANIFEST`: a successful run can have partial coverage or unattempted inputs. `fieldAvailability` distinguishes present, source_absent, not_requested and extraction_failed.

The default context is London **SW1A 1AA / GBP**. Override it with `locations["co.uk"].postalCode`. Every returned source response must verify that postcode and currency; proxy egress country is not delivery location. A timeout, challenge, unknown404 or absent price never means the product was deleted. Recognized missing pages are reported as `product_not_found` and are not charged. Used-only featured offers are explicitly marked; unknown condition is not assumed to be New.

### Pricing

| Event | Per 1000 successfully parsed products |
|---|---:|
| Search / un-enriched catalog listings | $0.90 |
| Lookup / unchanged monitor observations | $3.60 |
| Full product / enriched products | $4.50 |

Source infrastructure is included. **Each run has a $0.02 start fee** (fixed 1024 MB memory), including runs with no results. Product events are charged only for durable product rows without extraction failures. Confirmed missing products, failed products, occurrence rows and duplicate products within the same run have no per-product charge. A source-absent optional field is not an extraction failure. Distinct runs are separate observations. Normal Apify storage costs after a run may apply.

### Coverage and operational limits

Search ranking, sponsored placements, variants and offers may differ between sessions even at the same postcode. The Actor preserves primary result cards in the received pages; it does not promise the same ranking as your browser. Coverage is limited to the pages actually collected; cross-session ranking and universal recall are not guaranteed.

The release uses residential discovery and a bounded inexpensive product route with residential recovery for technical failures. All routes share request, traffic and time limits. No interactive CAPTCHA solving, cart actions, text reviews, exhaustive seller offers or variant hydration are included. Catalog merchant identity is separate from the featured-offer seller.

Outputs are incremental. Controlled migration resumes checkpoints; ambiguous storage or billing acknowledgements stop for reconciliation. Keep `restartOnError: false`, set page/item/time and Apify cost limits, and pin a tested build for integrations. Large jobs may return partial results when a limit is reached.

### Support

Open an Actor issue with the run ID, mode, ASIN/query and expected result. Never include API tokens. Use your own Apify token in the Authorization header.

### Start a price monitor

1. In this Actor's Console input, choose **products**, enable **Monitor a fixed product list**, and paste the [monitoring example below](#scheduled-product-monitoring). Replace the ASIN with a product you want to follow. Start with one product; increase `maxItems` to cover your list only after checking a complete run.
2. Choose **Save as a new task**. Keep the same task and `monitorKey` for later runs, along with the same delivery postcode and currency. `monitorKey` is a watchlist label, not an API token; use a non-sensitive label.
3. Run the task once to establish the baseline, then run the same task again. Inspect the Dataset **and** `MANIFEST` in the run's default key-value store. The first successful observation is `new`; a later observation is `unchanged` when no selected change meets the configured comparison rules. Sub-threshold price movement may still appear in `monitorValues`.
4. In **Schedules**, add this saved task, choose your timezone and a daily time, and set a maximum cost per run. Enable the schedule only after both manual runs are acceptable. Keep `resetMonitor: false` and allow enough time between runs to avoid overlap. [Apify schedule setup](https://docs.apify.com/actors/running/schedules).
5. Read `recordType: monitor` rows and deduplicate delivery using `eventId`. Process `changedFields`, `previous` and `monitorValues`; retain `unchanged` observations as freshness checks. If `contextChanged` is true, the seller/offer context changed: do not treat it as a like-for-like price movement.

For a 100-ASIN watchlist, the **illustrative event bill** is $0.47 for a first run where all 100 full cards are delivered and $0.38 for a run where all 100 are unchanged. One first run plus 29 unchanged daily runs totals **$11.49**. These figures include the current start fee, assume no discounts, no retries as separate runs, no changed/returned products, and exclude post-run storage charges. They are price calculations, not a 100-ASIN speed or completeness guarantee. Changed/returned products use the full-card rate.

`MANIFEST.status: partial` requires inspection of `errors` and coverage. A missing observation or a failed run is not a price drop or product removal. Confirmed `not_found` observations have no product-event charge; source failures do not advance the baseline. The Actor writes data to Apify and does not send customer emails or chat alerts automatically.

### Scheduled product monitoring

Set `mode: "products"`, `monitor: true`, and a fixed list of up to 200 ASINs or product URLs. Use the same `monitorKey` on each run, or save the input as an Apify task and schedule that task. History belongs to your account and is isolated by Actor, marketplace, delivery postcode and currency. Separate keys allow independent customer watchlists.

```json
{
  "mode": "products",
  "products": [
    "B09Y2MYL5C"
  ],
  "monitor": true,
  "monitorKey": "amazon-uk-daily",
  "monitorFields": [
    "price",
    "rating",
    "reviewCount"
  ],
  "minPriceChangePct": 3,
  "resetMonitor": false,
  "locations": {
    "co.uk": {
      "postalCode": "SW1A 1AA",
      "currency": "GBP",
      "deliveryCountry": "GB"
    }
  },
  "maxItems": 1
}
```

The first successful observation is `changeType: "new"`. Later runs return a full card for `changed` and `returned` products and a compact row for `unchanged` products. These rows have `recordType: "monitor"`, `eventId`, `recordId`, `observedAt`, `changedFields`, `previous`, and explicit `monitorValues` states. Full new/changed/returned rows use the existing **Product with full fields** (`product-item`) event. Unchanged rows use **Product lookup** (`lookup-item`); see the Pricing tab for current rates and any run-start fee. Unchanged rows are not charged again as full product rows. Unlike listing-based monitoring, Amazon monitoring still needs a current product-page response per ASIN; it does not eliminate those source requests.

- `monitorFields`: choose `price`, `rating`, `reviewCount`, and/or `availability`. Default: price, rating and reviewCount. Availability is visible source text, not an exact stock quantity.
- `minPriceChangePct`: cumulative price movement relative to the last notified price. A review-count or rating change does not reset that price baseline.
- Prices are compared only within a verified delivery postcode/currency and the same seller, condition, price type and offer context. A verified offer-context change starts a new context (`contextChanged: true`); it is not presented as a like-for-like price change. A page hiding its price or showing no featured offer is an explicit source state, not a zero price.
- A verified native Amazon not-found response produces a free result event, `changeType: "not_found"`. This means not found in that observed response, not proof of permanent removal. Source errors, challenges, incomplete responses and unavailable required fields appear in `MANIFEST.errors` and never become disappearance notifications. All-not-found batches can complete successfully.
- `resetMonitor: true` starts fresh baselines for successfully observed products; turn it off on the next scheduled run. It cannot bypass a pending unresolved delivery or charge.

Do not overlap runs sharing a history key. `monitor_busy` means another run owns that history. For `monitor_reconciliation_required`, keep the original run and history intact, share the run URL through Issues, and reconcile that run; changing the key or resetting must not be used to retry an uncertain charge. Resurrecting the original run can reconcile acknowledged output/charges, but may incur another platform run-start fee. `monitor_source_interrupted` prevents a resurrected run from silently resetting its paid source-request budget; the next ordinary scheduled run can make a fresh observation.

Only delivered, billing-confirmed observations advance history. Required field failures preserve the prior baseline. Read `MANIFEST.status`, `errors`, `coverage`, `counts` and `billing` on every run. Set limits large enough for the watchlist: `maxItems`, `maxRequests`, `maxWireBytes` and `maxRunSeconds` also apply in monitor mode. `additionalOffers` and query/catalog discovery are not accepted in this fixed-list monitor mode. Existing inputs with monitoring off keep their original behavior and output format.

# Actor input Schema

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

Choose product lookup, full product fields, search listings or seller catalog.

## `products` (type: `array`):

Amazon.co.uk ASINs or product URLs.

## `queries` (type: `array`):

Search phrases. Used by search_only or query-driven products mode.

## `sellerIds` (type: `array`):

Amazon merchant IDs for seller_catalog mode. Catalog identity is separate from the featured seller.

## `marketplaces` (type: `array`):

Only amazon.co.uk is supported.

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

Maximum distinct product identities in the collection.

## `maxItemsPerSource` (type: `integer`):

Maximum distinct products collected from each query or seller.

## `maxPagesPerSource` (type: `integer`):

Maximum source pages per query or seller. Reaching the cap is reported as partial coverage.

## `maxConcurrency` (type: `integer`):

Concurrent native workers. Maximum 4.

## `maxRequests` (type: `integer`):

Global source request budget, including location preparation and bounded retries.

## `maxRunSeconds` (type: `integer`):

Global source-work deadline in seconds.

## `maxWireBytes` (type: `integer`):

Maximum observed source traffic bytes. Failed-request estimates are reported separately.

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

Include source-marked sponsored search placements.

## `enrichProducts` (type: `boolean`):

seller_catalog only: fetch each discovered product card. Adds requests and cost.

## `locations` (type: `object`):

Optional British delivery context: {"co.uk":{"postalCode":"SW1A 1AA","currency":"GBP","deliveryCountry":"GB"}}.

## `maxRequestAttempts` (type: `integer`):

Bounded residential request attempts; inexpensive product route is tried once.

## `monitor` (type: `boolean`):

products mode with explicit ASINs/URLs, up to 200. Full rows for new/changed/returned products; compact unchanged rows; source-verified not-found observations. Keep a stable monitorKey or saved task.

## `monitorKey` (type: `string`):

Stable history identifier, 1–128 letters, digits, dots, underscores or hyphens. Optional only when using a saved task. Scoped to your account, Actor and delivery context.

## `monitorFields` (type: `array`):

Nonempty subset of price, rating, reviewCount, availability. Availability compares source text, not a stock quantity.

## `minPriceChangePct` (type: `number`):

Price change relative to the last notified price in the same seller/offer and delivery context. Other field changes do not reset this price baseline.

## `resetMonitor` (type: `boolean`):

Treat successfully observed products as new. Does not bypass an unresolved previous delivery/charge. Turn off after the intended reset run.

## Actor input object example

```json
{
  "mode": "lookup_only",
  "products": [
    "B09Y2MYL5C"
  ],
  "marketplaces": [
    "co.uk"
  ],
  "maxItems": 100,
  "maxItemsPerSource": 100,
  "maxPagesPerSource": 3,
  "maxConcurrency": 4,
  "maxRequests": 100,
  "maxRunSeconds": 180,
  "maxWireBytes": 40000000,
  "includeSponsored": true,
  "enrichProducts": false,
  "maxRequestAttempts": 3,
  "monitor": false,
  "monitorFields": [
    "price",
    "rating",
    "reviewCount"
  ],
  "minPriceChangePct": 0,
  "resetMonitor": false
}
```

# Actor output Schema

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

No description

## `manifest` (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 = {
    "mode": "lookup_only",
    "products": [
        "B09Y2MYL5C"
    ],
    "marketplaces": [
        "co.uk"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("commercestack/amazon-uk-search-product-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 = {
    "mode": "lookup_only",
    "products": ["B09Y2MYL5C"],
    "marketplaces": ["co.uk"],
}

# Run the Actor and wait for it to finish
run = client.actor("commercestack/amazon-uk-search-product-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 '{
  "mode": "lookup_only",
  "products": [
    "B09Y2MYL5C"
  ],
  "marketplaces": [
    "co.uk"
  ]
}' |
apify call commercestack/amazon-uk-search-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,commercestack/amazon-uk-search-product-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/Oz1kJbWtOMCmuwWXy/builds/eIbHlbahXduXlTWai/openapi.json
