# BaseNexo E-commerce Product & Price Monitor (`paulo_junior_14/basenexo-commerce-intelligence`) Actor

Track competitor prices, stock, and product changes across public e-commerce pages. Extract titles, prices, currencies, SKUs, availability, images, and descriptions; compare previous datasets; then export structured data to JSON, CSV, Excel, API, n8n, or MCP. Pay only for delivered results.

- **URL**: https://apify.com/paulo\_junior\_14/basenexo-commerce-intelligence.md
- **Developed by:** [Paulo Júnior](https://apify.com/paulo_junior_14) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 commerce results

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/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

**E-commerce price monitor and product scraper for public product pages.** Track competitor prices, stock availability, and product changes, then export clean product data to JSON, CSV, Excel, the Apify API, n8n, or MCP workflows.

BaseNexo converts different storefront layouts into one consistent dataset. It reads product JSON-LD, Open Graph and common commerce metadata, supports custom CSS selectors, and can compare a previous Apify dataset to identify exactly what changed.

### E-commerce price monitoring features

- Extract product title, price, currency, SKU, availability, image, description, and canonical URL.
- Monitor competitor price and stock changes across repeated runs.
- Classify every record as `new`, `changed`, or `unchanged`.
- Return the exact fields that changed, plus a stable SHA-256 fingerprint.
- Score data completeness from 0 to 100 so low-quality records are easy to filter.
- Add an optional BaseNexo AI insight when the analysis endpoint is configured.
- Use domain allowlists, page limits, concurrency limits, and `robots.txt` controls.
- Connect results to Apify API, schedules, webhooks, n8n, or MCP-compatible agents.

### What product data can you extract?

| Field | What it contains |
|---|---|
| `title` | Product name |
| `price` and `currency` | Normalized numeric price and currency code |
| `sku` | SKU or MPN when published on the page |
| `availability` | Normalized stock or availability text |
| `imageUrl` | Absolute primary product image URL |
| `description` | Product description |
| `changeType` | `new`, `changed`, or `unchanged` |
| `changedFields` | List of fields that changed since the baseline dataset |
| `qualityScore` | Completeness score from 0 to 100 |
| `fingerprint` | Stable SHA-256 fingerprint for deduplication and audits |
| `correlationId` and `runId` | Identifiers for API, n8n, and MCP orchestration |

One successfully processed input URL produces one normalized commerce result. Missing fields are returned as `null` instead of being invented.

### How to monitor competitor prices

1. Add public product URLs to **Product or listing URLs**.
2. Keep the default limits for a small test run.
3. Add CSS selectors only if the page does not expose standard product metadata.
4. Run the Actor and inspect the **Commerce overview** dataset.
5. For the next run, select the first dataset in **Previous dataset**.
6. Schedule the Actor daily or weekly and connect the results to your preferred automation.

The comparison output tells you whether each product is new, changed, or unchanged and identifies fields such as `price` or `availability` that moved.

### Input example

```json
{
  "startUrls": [
    {
      "url": "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html"
    }
  ],
  "selectors": {
    "title": "h1",
    "price": ".price_color",
    "availability": ".availability"
  },
  "maxRequestsPerCrawl": 50,
  "maxConcurrency": 3,
  "respectRobotsTxt": true,
  "includeAiInsight": false
}
```

#### Input options

| Option | Description | Default |
|---|---|---:|
| `startUrls` | Public HTTP(S) product pages to process | Required |
| `selectors` | Optional CSS selectors for fields that standard metadata does not expose | `{}` |
| `allowedDomains` | Optional domain allowlist; subdomains are accepted | All public domains |
| `previousDatasetId` | Dataset used as a baseline for product change detection | None |
| `maxRequestsPerCrawl` | Maximum pages processed, from 1 to 500 | 50 |
| `maxConcurrency` | Simultaneous page requests, from 1 to 10 | 3 |
| `respectRobotsTxt` | Honor the website's `robots.txt` rules | `true` |
| `includeAiInsight` | Request an optional BaseNexo AI analysis | `false` |
| `correlationId` | Your integration or audit identifier | Generated automatically |

### Output example

```json
{
  "sourceUrl": "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html",
  "canonicalUrl": "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html",
  "domain": "books.toscrape.com",
  "collectedAt": "2026-08-13T12:00:00.000Z",
  "title": "A Light in the Attic",
  "price": 51.77,
  "currency": "GBP",
  "sku": null,
  "availability": "in stock",
  "imageUrl": "https://books.toscrape.com/media/cache/example.jpg",
  "description": "A poetry collection.",
  "fingerprint": "sha256-fingerprint",
  "changeType": "changed",
  "changedFields": ["price"],
  "qualityScore": 80,
  "aiInsight": null,
  "correlationId": "price-monitor-daily",
  "runId": "APIFY_RUN_ID"
}
```

The default dataset is available in table view and can be downloaded as JSON, JSONL, CSV, Excel, XML, or RSS. The `OUTPUT` key-value-store record contains run totals, average quality score, limits, and failures.

### Product scraper API, n8n, and MCP integration

Run the e-commerce product scraper from the Apify Console, API, CLI, schedules, or integrations. Replace `YOUR_APIFY_TOKEN` before using this API example:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/paulo_junior_14~basenexo-commerce-intelligence/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://example.com/product"}],"maxRequestsPerCrawl":1}'
```

For n8n, call the Actor with an HTTP Request node or the Apify integration, wait for the run to finish, and read the default dataset. For AI agents, expose the Actor through Apify MCP and pass product URLs as structured input.

### E-commerce price monitor pricing

This Actor uses transparent pay-per-event pricing. Platform usage is included.

| Billable event | Price | Example |
|---|---:|---:|
| Commerce result successfully delivered | $0.005 | $5 per 1,000 results |
| Optional AI insight successfully delivered | $0.05 | $50 per 1,000 insights |
| Actor start | $0.00005 | One minimum start event |

Failed requests do not generate a `commerce-result` charge. An `ai-insight` charge occurs only when the insight is returned and included in a delivered result. Use the run spending limit and page limit to control budgets.

### Supported e-commerce sites and limitations

BaseNexo works best with public product pages that expose Product JSON-LD, Open Graph, microdata, or stable CSS selectors. This includes many independent stores and storefronts built with platforms such as Shopify or WooCommerce, but individual themes and anti-bot rules vary. Test representative URLs before a large run.

Current boundaries:

- Processes explicitly supplied URLs; it does not automatically discover a full catalog.
- Returns one normalized product record per successfully processed URL.
- Does not log in or bypass authentication, CAPTCHAs, access controls, or website terms.
- Does not access local, private-network, or credential-bearing URLs.
- JavaScript-only pages may need a future browser-based extractor or another Actor.
- Previous-dataset comparison reads up to the first 1,000 baseline records.

### Frequently asked questions

#### Can I track competitor prices automatically?

Yes. Run the same product URLs on a schedule and use the previous dataset as the comparison baseline. Filter for `changeType: "changed"` and `changedFields` containing `price`.

#### Can I monitor stock availability?

Yes. When availability is published in JSON-LD, microdata, or a configured CSS selector, the Actor normalizes it and detects changes between runs.

#### Can this product scraper collect an entire store?

Not automatically. The current version processes the URLs you supply. Feed it a prepared product URL list and set `maxRequestsPerCrawl` to the desired safety limit.

#### Does it work with Shopify and WooCommerce?

It can process public product pages from these and other platforms when product data is present in standard metadata or accessible through stable CSS selectors. Because themes differ, test a few representative URLs first.

#### How do I avoid duplicate product data?

Use `canonicalUrl` as the primary identity and `fingerprint` for exact-content deduplication. The Actor also returns `sourceUrl`, domain, collection time, correlation ID, and run ID for lineage.

#### Can I export results to Excel or JSON?

Yes. Apify datasets support JSON, JSONL, CSV, Excel, XML, and RSS exports. You can also retrieve results through the API or send them to downstream automations.

#### Is an AI insight required?

No. AI insights are optional and disabled by default. Core product extraction, price monitoring, availability tracking, change detection, and quality scoring work without AI.

### Responsible product data collection

Use only public pages you are authorized to access and follow applicable website terms and laws. The Actor respects `robots.txt` by default, supports domain allowlists, and blocks obvious private or local network targets. It does not bypass technical access controls.

### Support

If a public product page does not extract correctly, open an issue from the **Issues** tab and include the run ID, public example URL, expected field, and actual result. Never post API tokens, cookies, private URLs, or customer data.

- [BaseNexo support](https://basenexo.com.br/suporte)
- [Privacy policy](https://basenexo.com.br/legal/privacidade)
- [Terms of use](https://basenexo.com.br/legal/termos)

Ready to begin? Click **Try for free**, run the included example, and inspect the normalized commerce dataset.

# Actor input Schema

## `startUrls` (type: `array`):

Public HTTP(S) product pages to monitor. One successfully processed URL produces one result. Login-protected and private-network URLs are not supported.

## `selectors` (type: `object`):

Optional CSS selectors. JSON-LD and common commerce metadata are used first when available.

## `allowedDomains` (type: `array`):

Optional domain allowlist. Subdomains are accepted automatically.

## `previousDatasetId` (type: `string`):

Optional Apify dataset used as the comparison baseline for change detection.

## `maxRequestsPerCrawl` (type: `integer`):

Safety and budget limit for pages processed in this run (1 to 500).

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

Maximum simultaneous page requests (1 to 10).

## `respectRobotsTxt` (type: `boolean`):

Honor website robots.txt rules. Recommended and enabled by default.

## `includeAiInsight` (type: `boolean`):

Request one concise insight from the owner-configured BaseNexo analysis workflow. Disabled when the endpoint is not configured.

## `correlationId` (type: `string`):

Optional identifier for n8n, API, or MCP orchestration and audit correlation.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html"
    }
  ],
  "selectors": {},
  "allowedDomains": [],
  "maxRequestsPerCrawl": 50,
  "maxConcurrency": 3,
  "respectRobotsTxt": true,
  "includeAiInsight": false
}
```

# Actor output Schema

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

Normalized product, price, change, quality, and lineage records.

## `summary` (type: `string`):

Counts, configuration, failures, and quality aggregate for this run.

# 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("paulo_junior_14/basenexo-commerce-intelligence").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("paulo_junior_14/basenexo-commerce-intelligence").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 '{}' |
apify call paulo_junior_14/basenexo-commerce-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,paulo_junior_14/basenexo-commerce-intelligence"
        }
    }
}

```

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/0FmTKkQkKqGM3wI8D/builds/7e1dvZsDb0hKyOgIe/openapi.json