# Priceme Product Search Scraper (`stealth_mode/priceme-product-search-scraper`) Actor

Scrape product listings from Prisradar.no search results with complete pricing and shop data. Collect titles, prices, discounts, promotional status, variants, and 20+ fields per product — ideal for price intelligence, market research, and competitive analysis.

- **URL**: https://apify.com/stealth\_mode/priceme-product-search-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (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 $2.00 / 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Priceme.co.nz Product Search Scraper: Extract NZ Retail Pricing Data Fast
---

### What Is Priceme.co.nz?

Priceme.co.nz is New Zealand's leading price comparison platform, aggregating product listings and pricing information from hundreds of retailers across categories like electronics, fragrances, appliances, and more. With millions of product records and real-time price updates, it's a goldmine for competitive intelligence and market analysis. However, manually collecting product data is impractical at scale — the **Priceme Product Search Scraper** automates extraction of product details, pricing, ratings, and comparison URLs directly from search results.

---

### Overview

The **Priceme Product Search Scraper** extracts detailed product information from Priceme.co.nz search result pages, converting unstructured listings into structured, machine-readable records. It captures 20+ fields per product, including prices, ratings, images, and merchant comparison links.

**Ideal users:**
- **Price aggregators** building competing price comparison services
- **Retailers** monitoring competitor pricing and availability
- **E-commerce analysts** studying NZ market trends and price elasticity
- **Product researchers** collecting data for market analysis and benchmarking
- **Marketing teams** tracking product launches and promotional trends

**Key features:**
- Configurable item limits per URL
- Flexible sorting and filtering through search parameters
- Graceful error handling via `ignore_url_failures`
- Rich output including product ratings, images, and multiple URL formats

---

### Input Format

The scraper accepts a JSON configuration object defining which product listings to scrape:

```json
{
  "urls": [
    "https://www.priceme.co.nz/fragrances/c-1285.aspx?sb=Clicks&view=tiles"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

| Parameter | Type | Description |
|---|---|---|
| `urls` | Array | List of Priceme.co.nz product search/category URLs to scrape. Each URL should point to a search results or category listing page. |
| `ignore_url_failures` | Boolean | If `true`, scraper continues even if some URLs fail. If `false`, the run stops on the first error. Default: `true`. |
| `max_items_per_url` | Integer | Maximum number of products to extract per URL (e.g., `200`). Useful for limiting data volume or testing. |

***

### Output Format

**Example output record:**

```json
{
  "product_id": 902251571,
  "product_name": "Armaf Club De Nuit Intense EDT 105ml",
  "name_url": "/Armaf-Club-De-Nuit-Intense-EDT-105ml/p-902251571.aspx",
  "name_url_target": "_self",
  "compare_url": "/Armaf-Club-De-Nuit-Intense-EDT-105ml/p-902251571.aspx",
  "compare_url_target": "_self",
  "default_image": "https://s3.pricemestatic.com/Images/RetailerProductImages/StRetailer1216/0043793446_ms.jpg",
  "image_alt": "Armaf Club De Nuit Intense EDT 105ml",
  "price": 67.99,
  "price_string": "$67.99",
  "rating_score_data_string": "",
  "compare_prices_string": "Compare prices from 4 shops",
  "buying_guide_html": null,
  "rating_hidden": "hidden",
  "tag_class_name": "tagDiv bSeller",
  "tag_text": "Bestseller",
  "favs_class": "favourite-icon",
  "favs_value": "1",
  "favs_state": null,
  "svg_class_name": "hidden",
  "my_url": null,
  "pre_load": null,
  "item_class_name": null,
  "from_url": "https://www.priceme.co.nz/fragrances/c-1285.aspx?sb=Clicks&view=tiles"
}
```

Each product record includes 20+ fields capturing pricing, product details, ratings, and navigation data:

#### Product Identification

| Field | Description |
|---|---|
| `Product ID` | Unique identifier for the product on Priceme |
| `Product Name` | Full product title as displayed |
| `Name URL` | Direct link to the product detail page |
| `Name URL Target` | Link target attribute (typically `_blank` for external) |
| `My URL` | Relative or canonical product URL |

#### Pricing & Comparison

| Field | Description |
|---|---|
| `Price` | Current lowest price (numeric value) |
| `Price String` | Formatted price display (e.g., "$45.99" or "$45.99 - $52.00") |
| `Compare URL` | Direct link to the price comparison page |
| `Compare URL Target` | Target attribute for comparison link |
| `Compare Prices String` | Text summarizing available price range or merchant options |

#### Product Images & Media

| Field | Description |
|---|---|
| `Default Image` | URL to the primary product image |
| `Image Alt` | Alternative text for the image (accessibility/SEO) |

#### Ratings & Reviews

| Field | Description |
|---|---|
| `Rating Score Data String` | Rating data in text format (e.g., "4.5/5 from 120 reviews") |
| `Rating Hidden` | Boolean flag indicating if ratings are hidden for this product |

#### User Interactions & Favorites

| Field | Description |
|---|---|
| `Favs Class` | CSS class name applied to the favorites button |
| `Favs Value` | Numeric count of favorites or bookmark status |
| `Favs State` | Current state of the favorite toggle (e.g., "favorited", "not-favorited") |

#### Tags & Categorization

| Field | Description |
|---|---|
| `Tag Class Name` | CSS class applied to product tags (e.g., "hot-deal", "bestseller") |
| `Tag Text` | Visible text of the tag (e.g., "Hot Deal", "New Arrival") |

#### Technical Fields

| Field | Description |
|---|---|
| `SVG Class Name` | CSS class for SVG icons used in the listing |
| `Pre Load` | Preload attribute for resource optimization |
| `Item Class Name` | CSS class name of the product list item container |
| `Buying Guide HTML` | Embedded HTML content or link to buying guide for the product |

***

### How to Use

#### Step 1: Identify Your URLs

Navigate to Priceme.co.nz and find the category or search results page you want to scrape. Copy the full URL from your browser's address bar.

#### Step 2: Configure Input

Paste URLs into the `urls` array. You can add multiple URLs to scrape different categories or searches in one run.

```json
{
  "urls": [
    "https://www.priceme.co.nz/fragrances/c-1285.aspx",
    "https://www.priceme.co.nz/laptops/c-2101.aspx"
  ],
  "max_items_per_url": 100,
  "ignore_url_failures": true
}
```

#### Step 3: Set Item Limits

Adjust `max_items_per_url` to control data volume. For testing, use `20`; for comprehensive scrapes, use `200` or higher.

#### Step 4: Run & Export

Execute the scraper. Results are available as JSON, CSV, or Excel. Filter and export based on your analysis needs.

**Best practices:**

- Test with a single URL before running multiple URLs
- Use URL parameters (`?sb=Clicks&view=tiles`) for consistent page structure
- Set reasonable `max_items_per_url` to avoid excessive data collection
- Enable `ignore_url_failures` for robustness in production runs

**Troubleshooting:**

- **No results:** Verify the URL points to a valid Priceme search or category page, not a product detail page
- **Incomplete data:** Some products may lack ratings or images; this reflects actual page content
- **Rate limiting:** Space out large-scale scrapes to avoid IP blocking

***

### Use Cases & Benefits

**Price monitoring:** Track competitor pricing in real-time across categories (e.g., fragrances, electronics)

**Market research:** Analyze pricing trends, product availability, and merchant coverage in the NZ market

**Retail intelligence:** Benchmark your pricing against competitors and identify market gaps

**Product aggregation:** Feed Priceme data into your own price comparison tool or marketplace

**Trend analysis:** Study which products are trending (via favorites and ratings) and optimize inventory

The Priceme Product Search Scraper saves days of manual data collection, enabling data-driven decisions in e-commerce, retail strategy, and competitive analysis.

***

### Conclusion

The **Priceme.co.nz Product Search Scraper** unlocks New Zealand's richest price comparison data in minutes. With 20+ structured fields per product, flexible URL configuration, and robust error handling, it's the fastest way to extract competitive pricing and product insights at scale. Start scraping today and gain a data advantage in the NZ retail market.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.priceme.co.nz/fragrances/c-1285.aspx?sb=Clicks&view=tiles"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.priceme.co.nz/fragrances/c-1285.aspx?sb=Clicks&view=tiles"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/priceme-product-search-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 = {
    "urls": ["https://www.priceme.co.nz/fragrances/c-1285.aspx?sb=Clicks&view=tiles"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/priceme-product-search-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 '{
  "urls": [
    "https://www.priceme.co.nz/fragrances/c-1285.aspx?sb=Clicks&view=tiles"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/priceme-product-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=stealth_mode/priceme-product-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Priceme Product Search Scraper",
        "description": "Scrape product listings from Prisradar.no search results with complete pricing and shop data. Collect titles, prices, discounts, promotional status, variants, and 20+ fields per product — ideal for price intelligence, market research, and competitive analysis.",
        "version": "0.0",
        "x-build-id": "w6xpTKWqXFiyJ9Iig"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~priceme-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-priceme-product-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/stealth_mode~priceme-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-priceme-product-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/stealth_mode~priceme-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-priceme-product-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "urls": {
                        "title": "URLs of the product search list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product search list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
