# nopCommerce Product Scraper & Catalog Monitor (`clintsa/nopcommerce-product-catalog-scraper`) Actor

Export product catalogs from public nopCommerce shops. Export JSON or CSV and monitor changes. $0.75 per 1,000 rows plus $0.001 per run.

- **URL**: https://apify.com/clintsa/nopcommerce-product-catalog-scraper.md
- **Developed by:** [Andy Besos](https://apify.com/clintsa) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 1 total users, 1 monthly users, 80.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.75 / 1,000 nopcommerce 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

nopCommerce Product Scraper & Catalog Monitor helps you export product catalogs from public nopCommerce shops. Collect product IDs, names, SKUs, prices, stock status, manufacturer part numbers, categories and images for assortment research or a recurring product feed.

Start with a product URL, then use a category or storefront URL for broader discovery. Public pages need no merchant login or authenticated nopCommerce Web API. Actor event charges at the default 256 MB memory are **$0.001 per run plus $0.00075 per exported row**: **$0.751 for 1,000 rows**.

Selected fields from a recent successful run; source values can change:

```json
{
  "id": "1434",
  "sku": "1434",
  "name": "Slider Manager",
  "price": 50,
  "currency": "USD",
  "inStock": true
}
```

### Why use this nopCommerce scraper?

- **nopCommerce product fields:** SKU and manufacturer part number have their own columns, alongside the ordinary price, stock, categories and images.
- **Store, category and product inputs:** Use a whole shop for discovery or a product URL for a quick single-row check.
- **Public JSON and HTML paths:** A recognized unauthenticated catalog JSON response is parsed directly; category and product HTML provide coverage when that endpoint is unavailable.
- **Repeatable change monitoring:** A persistent monitor ID distinguishes new, updated, unchanged and removed products on later runs.
- **Responsible crawl controls:** The Actor reads robots.txt, requests pages sequentially per store, and lets you set the delay and page caps. It retries temporary HTTP failures and keeps an error on one store from ending a run that succeeds on another.

The output identifies the source URL for each product. When a crawl stops early or a page fails, the summary marks the store incomplete and the monitor suppresses removal events for products it could not recheck.

### Pricing

This Actor uses pay per event pricing: **$0.001 per run plus $0.00075 per product row exported** at the default memory size. A row is billed when it is written to the dataset, including an unchanged row on a normal repeat run. Limits and change-only filters can reduce exported rows. Check the Pricing tab for the current charge schedule before a large job.

| Exported products | Estimated event charge |
| ---: | ---: |
| 1 | $0.00175 |
| 100 | $0.076 |
| 1,000 | $0.751 |
| 10,000 | $7.501 |

These figures use one start event and exclude any optional proxy charges. A larger memory allocation can change the number of start events.

### How to use this Actor

Paste one or more public nopCommerce URLs into `stores`. A bare hostname such as `www.foxnetsoft.com` is accepted; full URLs are clearer. A direct product URL is ideal for a fast first run:

```json
{
  "stores": [
    "https://www.foxnetsoft.com/nopslidermanager"
  ],
  "maxItemsPerStore": 1
}
```

Click **Start**, inspect the Dataset, then export JSON or CSV. Check the product ID, SKU and currency first. Public fields vary by theme; a missing stock quantity or manufacturer part number is not inferred.

For a wider catalog, use a storefront or category URL. The Actor follows product cards, category navigation and pagination on the same host. Increase page caps only after checking the shop's crawl policy:

```json
{
  "stores": ["https://www.foxnetsoft.com/userinterfaceandwidgets"],
  "maxItemsPerStore": 100,
  "maxListingPages": 20,
  "maxProductPages": 100,
  "requestDelayMillis": 500
}
```

The `stores` array can contain several shops. Each shop is handled separately, and all successful product rows go into the same dataset.

### Monitor new, updated, and removed products

Schedule the same input with the same `monitorId`. The first successful run establishes a snapshot. Later runs compare public product fields with that snapshot.

| `changeType` | Meaning |
| --- | --- |
| `new` | Product first appeared in this monitor. |
| `updated` | A monitored field changed; see `changedFields`. |
| `unchanged` | Product is still present with the same public fields. |
| `removed` | Product was absent from a complete later scan. |

To export only recent changes, add an ISO timestamp such as `"onlyChangesSince": "2026-10-01T00:00:00.000Z"`. Do not use different page caps or category scopes under the same monitor ID when comparing whole catalogs. An incomplete scan does not produce `removed` events, because a page cap or request error is not proof that a product disappeared.

### API example

Run the Actor and get its dataset items in one call. Replace the token placeholder with your Apify token:

```bash
curl -X POST 'https://api.apify.com/v2/acts/Clintsa~nopcommerce-product-catalog-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"stores":["https://www.foxnetsoft.com/nopslidermanager"],"maxItemsPerStore":1}'
```

### Input options

| Field | Purpose |
| --- | --- |
| `stores` | Required array of public nopCommerce store, category or product URLs or hostnames. |
| `maxItemsPerStore` | Maximum exported rows per store; `0` exports all scanned rows. Prefill is `1`. |
| `maxListingPages` | Maximum category and pagination pages per store. |
| `maxProductPages` | Maximum discovered product pages per store; `0` means all discovered pages. |
| `requestDelayMillis` | Minimum delay between requests to one store, in milliseconds. |
| `monitorId` | Persistent namespace for snapshots across scheduled runs. |
| `onlyChangesSince` | Optional timestamp that limits dataset output to recent changes. |
| `useApifyProxy` | Optional proxy routing for stores that restrict data center traffic. |
| `proxyConfiguration` | Optional Apify Proxy settings when proxy use is enabled. |

### Output

One product row from the public [FoxNetSoft nopCommerce storefront](https://www.foxnetsoft.com/nopslidermanager) looks like this; monitoring timestamps change on each run:

```json
{
  "target": "https://www.foxnetsoft.com/nopslidermanager",
  "itemId": "1434",
  "id": "1434",
  "sku": "1434",
  "name": "Slider Manager",
  "url": "https://www.foxnetsoft.com/nopslidermanager",
  "price": 50,
  "currency": "USD",
  "inStock": true,
  "stockText": null,
  "manufacturerPartNumber": "SliderManager.FoxNetSoft.Plugin.Misc",
  "categories": ["User interface & widgets"],
  "images": ["https://www.foxnetsoft.com/images/thumbs/0005765_slider-manager.png"],
  "sourceUrl": "https://www.foxnetsoft.com/nopslidermanager",
  "scrapedAt": "2026-10-02T12:00:00.000Z",
  "changeType": "new",
  "changeDetectedAt": "2026-10-02T12:00:00.000Z",
  "firstSeenAt": "2026-10-02T12:00:00.000Z",
  "lastSeenAt": "2026-10-02T12:00:00.000Z"
}
```

The `SUMMARY` record in the run's key-value store reports requested and successful stores, scanned and exported products, crawl completeness, source mode, and change counts. The dataset offers catalog and change views.

### Use cases

- Move a niche shop's public catalog into a migration worksheet.
- Compare publicly displayed prices and stock across suppliers.
- Build marketplace product intake from several nopCommerce merchants.
- Track SKU, manufacturer part number and product URL mappings.
- Schedule catalog checks and review changed product fields.

### FAQ

**Does this work on every nopCommerce store?** It works when public product pages or a supported public JSON response are reachable. Shops can customize themes, restrict crawlers or hide fields.

**Is the official nopCommerce Web API public?** Its [documentation](https://docs.nopcommerce.com/en/developer/web-api/index.html) describes an optional plugin with token-based authentication. This Actor does not log in or use private endpoints.

**Where do SKUs and manufacturer part numbers come from?** The Actor reads public nopCommerce detail markup or product structured data. Missing public values are `null`.

**What does `inStock: null` mean?** The product page did not provide a reliable public availability value. It does not mean out of stock.

**Can I monitor deleted products?** Yes, after two complete scans of the same scope and monitor ID. An incomplete scan never treats unseen products as removed.

**Why did my store return no products?** Check the run log for robots restrictions, HTTP blocks, a custom theme without recognized product links, or page caps that stopped discovery.

### Limitations and responsible use

This Actor reads public catalog information only. It does not obtain hidden inventory counts, customer-specific prices, private variants, login-only records or merchant exports. A displayed price or stock label is an observation at scrape time, not a guarantee of current availability. Respect each site's terms, robots directives and rate limits, and use the data lawfully.

### Support

Open the Actor's Issues tab with the run ID, a public example URL and the input used. Include the field you expected if a customized nopCommerce theme is missing data.

Related tools: [nopCommerce Reviews Scraper & Change Monitor](https://apify.com/clintsa/nopcommerce-product-review-extractor).

# Actor input Schema

## `stores` (type: `array`):

One or more public nopCommerce storefront, category or product URLs. Enter full HTTP(S) links or hostnames. A direct product URL is the fastest way to test one row.

## `maxItemsPerStore` (type: `integer`):

Maximum product rows exported from each store. Set to 0 for every scanned product. This limits output after scanning so change monitoring uses the fetched snapshot.

## `maxListingPages` (type: `integer`):

Maximum category and pagination pages to fetch per store, including the starting page. Limited or failed crawls do not emit removal events.

## `maxProductPages` (type: `integer`):

Maximum product pages to fetch after discovery; 0 means all discovered products. Limited crawls do not emit removal events.

## `requestDelayMillis` (type: `integer`):

Minimum time between HTTP requests to the same store. Increase it to fit the store policy or lower server load.

## `monitorId` (type: `string`):

Persistent snapshot namespace. Keep it unchanged for repeated scans of the same store scope; choose a new value for an independent schedule.

## `onlyChangesSince` (type: `string`):

Optional ISO 8601 timestamp. Export only new, updated or removed products detected since this time. Leave blank to include unchanged products.

## `useApifyProxy` (type: `boolean`):

Optional network route for stores that restrict data center traffic. The example product works directly. Robots restrictions and challenges are still respected.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy settings, applied only when Use Apify Proxy is enabled.

## Actor input object example

```json
{
  "stores": [
    "https://www.foxnetsoft.com/nopslidermanager"
  ],
  "maxItemsPerStore": 1,
  "maxListingPages": 20,
  "maxProductPages": 100,
  "requestDelayMillis": 250,
  "monitorId": "default",
  "useApifyProxy": false
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "stores": [
        "https://www.foxnetsoft.com/nopslidermanager"
    ],
    "maxItemsPerStore": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("clintsa/nopcommerce-product-catalog-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 = {
    "stores": ["https://www.foxnetsoft.com/nopslidermanager"],
    "maxItemsPerStore": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("clintsa/nopcommerce-product-catalog-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 '{
  "stores": [
    "https://www.foxnetsoft.com/nopslidermanager"
  ],
  "maxItemsPerStore": 1
}' |
apify call clintsa/nopcommerce-product-catalog-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,clintsa/nopcommerce-product-catalog-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/F5d9FTXFAKU4BeRqD/builds/t6rBLimfEDGqCuOQp/openapi.json