# Smart Website Change Monitor (`hightower06/smart-website-change-monitor`) Actor

Monitor any public webpage for price, stock, text, and job listing changes. Get meaningful change detection without manually checking websites. Includes persistent baselines, noise filtering, automatic browser fallback, webhooks, CSS selector monitoring, and optional AI summaries.

- **URL**: https://apify.com/hightower06/smart-website-change-monitor.md
- **Developed by:** [Salih Brc](https://apify.com/hightower06) (community)
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 page checkeds

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

## Smart Website Change Monitor

Stop manually checking websites for changes.

**Smart Website Change Monitor** tracks public webpages and reports meaningful changes in **prices, stock availability, text content, and job listings** without alerting you for every timestamp, cookie banner, rotating widget, or minor HTML update.

### What can you monitor?

- **Price changes** — detect increases and decreases
- **Stock availability** — track in-stock / out-of-stock transitions
- **Job listings** — detect added or removed job links
- **Text changes** — watch meaningful content updates
- **Specific page sections** — monitor only the CSS selector you care about
- **Webhooks** — send detected changes to your own automation
- **Optional AI summaries** — turn a detected change into a short explanation

### Common use cases

#### Competitor price monitoring

Track product pages and detect when a competitor changes a price.

#### Stock alerts

Monitor unavailable products and detect when they return to stock.

#### Career page monitoring

Watch company career pages for newly added or removed job openings.

#### Terms, policy, and documentation monitoring

Detect meaningful updates to pricing pages, terms, policies, release notes, or documentation.

#### Supplier monitoring

Track supplier pages for price, availability, and content changes.

### Quick start

1. Add one or more webpage URLs.
2. Keep **Monitoring mode** on `Auto` for most pages.
3. Optionally add a CSS selector such as `.product_main`, `#price`, or `main`.
4. Run the Actor once to create a baseline.
5. Run it again manually or on an Apify Schedule.
6. Read the dataset output or send meaningful changes to a webhook.

For most users, the defaults are enough.

#### Recommended first product-page test

Use:

`https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html`

Recommended settings:

- Monitoring mode: `Auto`
- Page rendering: `HTTP only`
- CSS selector: `.product_main`

The Actor should extract the product price and stock status, then save them as the baseline.

### How it works

The first successful run creates a baseline in a named Apify key-value store. Future runs compare the current page against the previous successful observation.

A state key includes the URL, monitoring mode, and CSS selector, so different monitoring configurations do not overwrite one another.

The Actor uses a low-cost HTTP request first. In `auto` rendering mode, it falls back to a Chromium browser only when the page appears blocked, returns an error, or looks essentially empty.

### Monitoring modes

- `auto` — price + stock + job links + meaningful text
- `text` — substantial text changes only
- `price` — extracted price changes
- `stock` — availability transitions
- `jobs` — added or removed detected job links

### Reducing false alerts

For noisy or highly dynamic pages, set a CSS selector to the smallest stable page section you care about.

Examples:

- `#price`
- `.product-info`
- `.product_main`
- `main`

The Actor also removes common non-content elements and supports custom ignore selectors.

### Persistent monitoring

Default state store: `smart-change-monitor-state`

Keep the state-store name unchanged for scheduled monitoring. Use **Reset baseline** only when you intentionally want the current page to become the new reference state.

### Webhook notifications

Set `notificationWebhookUrl` to POST meaningful detected changes to Make, Zapier, Slack bridges, your own API, or another automation system.

If your endpoint requires authentication, add an encrypted bearer token in `webhookBearerToken`.

### Optional AI summaries

AI is an optional enhancement, not a dependency. The deterministic monitor decides whether a change happened.

If enabled, provide your own encrypted OpenAI API key. The Actor uses a low-cost text model by default to summarize the detected before/after change. AI-summary failure does not break core monitoring.

### Output

Each dataset item can include:

- URL and final URL
- status: initialized / changed / unchanged / error
- deterministic summary
- optional AI summary
- significance score
- text-change percentage
- prices before and after
- stock state before and after
- stock evidence before and after
- jobs added and removed
- HTTP or browser fetch method
- timestamps

The dataset includes **Overview** and **Details** views for easier inspection.

### Pricing

This Actor uses transparent **pay-per-event pricing**:

- **Page checked:** $2.00 per 1,000 pages
- **Browser render:** $5.00 per 1,000 renders
- **Change detected:** $0.008 per detected change
- **AI change summary:** $0.01 per summary
- **Actor start:** $0.00005 per run

Most pages are checked using lightweight HTTP requests first. Browser rendering is used only when needed, helping keep monitoring costs low.

You only pay for the events used during your runs. AI summaries are optional.

See the **Pricing** tab in Apify Store for the current pricing configuration.

### Reliability and responsible use

- Monitor only public pages you are allowed to access.
- Follow applicable website terms, laws, and rate limits.
- `auto` rendering is designed for compatibility and cost control, not to bypass access restrictions.
- Some CAPTCHA or sophisticated anti-bot systems may prevent collection.
- A narrow CSS selector is strongly recommended for highly dynamic pages.
- Price extraction favors structured data before text matching.
- Stock extraction recognizes common English and Turkish availability language.
- Job mode works best on dedicated careers/listing pages.

### Support

If you encounter an issue, use the **Issues** tab on the Actor's Apify Store page and include the target URL (when shareable), monitoring mode, rendering mode, and the relevant run ID.

# Actor input Schema

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

Add one or more public webpage URLs. For a quick first test, leave the default URL and run the Actor.

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

Choose what matters. Auto detects price, stock, job links, and meaningful text changes.

## `selector` (type: `string`):

Optional. Monitor only a stable section such as #price, .product-info, or main to reduce false alerts.

## `renderMode` (type: `string`):

Auto first tries a cheap HTTP request and falls back to a real browser when the page appears blocked or empty.

## `ignoreSelectors` (type: `array`):

Dynamic elements that should not trigger changes, such as cookie banners or live counters.

## `minTextChangePercent` (type: `number`):

Text changes below this percentage are treated as noise unless price/stock/jobs changed.

## `minimumSignificance` (type: `integer`):

Only changes at or above this 0-100 score are emitted as meaningful changes.

## `emitBaseline` (type: `boolean`):

If enabled, the first successful observation is written to the dataset as an initialized result.

## `emitUnchanged` (type: `boolean`):

Write an output row even when nothing changed. Recommended for monitoring history and Apify Store health checks.

## `resetBaseline` (type: `boolean`):

Overwrite the saved baseline on this run instead of reporting changes.

## `stateStoreName` (type: `string`):

Named key-value stores are retained indefinitely on Apify. Keep this value stable for scheduled monitoring.

## `requestTimeoutSecs` (type: `integer`):

Maximum time to wait for each HTTP or browser page request before treating it as an error.

## `browserWaitSecs` (type: `number`):

Extra time after DOMContentLoaded for JavaScript-heavy pages.

## `maxTextChars` (type: `integer`):

Caps normalized text stored per page to keep persistent state compact.

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

Optional Apify Proxy settings for public pages that need a proxy. Start without proxy unless required.

## `notificationWebhookUrl` (type: `string`):

POST all meaningful changes to this endpoint after the run. Useful with Make, Zapier, Slack bridges, or your own API.

## `webhookBearerToken` (type: `string`):

Stored encrypted by Apify.

## `enableAiSummary` (type: `boolean`):

Requires your own OpenAI API key. The Actor still works fully without AI.

## `openaiApiKey` (type: `string`):

Only used when AI summaries are enabled. Stored encrypted by Apify.

## `openaiModel` (type: `string`):

A low-cost text model is recommended because the deterministic change detector already does the core work.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://example.com/"
    }
  ],
  "mode": "auto",
  "renderMode": "auto",
  "ignoreSelectors": [
    "script",
    "style",
    "noscript",
    "template",
    "svg",
    "canvas",
    "[aria-live='polite']"
  ],
  "minTextChangePercent": 5,
  "minimumSignificance": 15,
  "emitBaseline": true,
  "emitUnchanged": true,
  "resetBaseline": false,
  "stateStoreName": "smart-change-monitor-state",
  "requestTimeoutSecs": 35,
  "browserWaitSecs": 1.5,
  "maxTextChars": 50000,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "enableAiSummary": false,
  "openaiModel": "gpt-5.6-luna"
}
```

# Actor output Schema

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

Price, stock, text, and job change results from the default dataset.

# 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 = {
    "startUrls": [
        {
            "url": "https://example.com/"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("hightower06/smart-website-change-monitor").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 = {
    "startUrls": [{ "url": "https://example.com/" }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("hightower06/smart-website-change-monitor").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 '{
  "startUrls": [
    {
      "url": "https://example.com/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call hightower06/smart-website-change-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hightower06/smart-website-change-monitor"
        }
    }
}
```

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/9k5N0XgDrOeld9Lss/builds/FGY393QfQ78YgyGNb/openapi.json